64#include "llvm/ADT/APFloat.h"
65#include "llvm/ADT/APInt.h"
66#include "llvm/ADT/APSInt.h"
67#include "llvm/ADT/ArrayRef.h"
68#include "llvm/ADT/DenseMap.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/STLExtras.h"
71#include "llvm/ADT/SmallBitVector.h"
72#include "llvm/ADT/SmallPtrSet.h"
73#include "llvm/ADT/SmallString.h"
74#include "llvm/ADT/SmallVector.h"
75#include "llvm/ADT/StringExtras.h"
76#include "llvm/ADT/StringRef.h"
77#include "llvm/ADT/StringSet.h"
78#include "llvm/ADT/StringSwitch.h"
79#include "llvm/Support/AtomicOrdering.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/Compiler.h"
82#include "llvm/Support/ConvertUTF.h"
83#include "llvm/Support/ErrorHandling.h"
84#include "llvm/Support/Format.h"
85#include "llvm/Support/Locale.h"
86#include "llvm/Support/MathExtras.h"
87#include "llvm/Support/SaveAndRestore.h"
88#include "llvm/Support/raw_ostream.h"
89#include "llvm/TargetParser/Triple.h"
103using namespace clang;
107 unsigned ByteNo)
const {
121 unsigned MinArgCount) {
122 unsigned ArgCount = Call->getNumArgs();
123 if (ArgCount >= MinArgCount)
126 return S.
Diag(Call->getEndLoc(), diag::err_typecheck_call_too_few_args)
127 << 0 << MinArgCount << ArgCount
128 << Call->getSourceRange();
135 unsigned ArgCount = Call->getNumArgs();
136 if (ArgCount <= MaxArgCount)
138 return S.
Diag(Call->getEndLoc(),
139 diag::err_typecheck_call_too_many_args_at_most)
140 << 0 << MaxArgCount << ArgCount
141 << Call->getSourceRange();
148 unsigned MaxArgCount) {
156 unsigned ArgCount = Call->getNumArgs();
157 if (ArgCount == DesiredArgCount)
162 assert(ArgCount > DesiredArgCount &&
"should have diagnosed this");
165 SourceRange Range(Call->getArg(DesiredArgCount)->getBeginLoc(),
166 Call->getArg(ArgCount - 1)->getEndLoc());
168 return S.
Diag(Range.getBegin(), diag::err_typecheck_call_too_many_args)
169 << 0 << DesiredArgCount << ArgCount
170 << Call->getArg(1)->getSourceRange();
174 if (
Value->isTypeDependent())
205 if (!Literal || !Literal->isOrdinary()) {
218 S.
Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
226 auto *Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
227 if (!Literal || !Literal->isWide()) {
228 S.
Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
229 << Arg->getSourceRange();
263 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(
294 bool IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;
296 auto IsValidIntegerType = [](
QualType Ty) {
297 return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
304 if ((!SrcTy->
isPointerType() && !IsValidIntegerType(SrcTy)) ||
308 S.
Diag(Source->getExprLoc(), diag::err_typecheck_expect_scalar_operand)
314 if (!IsValidIntegerType(AlignOp->
getType())) {
325 llvm::APSInt AlignValue = AlignResult.
Val.
getInt();
326 llvm::APSInt MaxValue(
327 llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
328 if (AlignValue < 1) {
329 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_too_small) << 1;
332 if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
337 if (!AlignValue.isPowerOf2()) {
338 S.
Diag(AlignOp->
getExprLoc(), diag::err_alignment_not_power_of_two);
341 if (AlignValue == 1) {
342 S.
Diag(AlignOp->
getExprLoc(), diag::warn_alignment_builtin_useless)
343 << IsBooleanAlignBuiltin;
368 unsigned BuiltinID) {
373 for (
unsigned I = 0; I < 2; ++I) {
397 !PtrTy->getPointeeType()->isIntegerType() ||
398 PtrTy->getPointeeType().isConstQualified()) {
400 diag::err_overflow_builtin_must_be_ptr_int)
408 if (BuiltinID == Builtin::BI__builtin_mul_overflow) {
409 for (
unsigned I = 0; I < 3; ++I) {
410 const auto Arg = TheCall->
getArg(I);
413 if (Ty->isBitIntType() && Ty->isSignedIntegerType() &&
415 return S.
Diag(Arg->getBeginLoc(),
416 diag::err_overflow_builtin_bit_int_max_size)
425struct BuiltinDumpStructGenerator {
434 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
435 Policy(S.Context.getPrintingPolicy()) {
439 Expr *makeOpaqueValueExpr(
Expr *Inner) {
442 Inner->getObjectKind(), Inner);
443 Actions.push_back(OVE);
447 Expr *getStringLiteral(llvm::StringRef Str) {
453 bool callPrintFunction(llvm::StringRef Format,
457 Args.reserve((TheCall->
getNumArgs() - 2) + 1 + Exprs.size());
459 Args.push_back(getStringLiteral(Format));
460 Args.insert(Args.end(), Exprs.begin(), Exprs.end());
476 Actions.push_back(RealCall.
get());
482 Expr *getIndentString(
unsigned Depth) {
488 return getStringLiteral(Indent);
492 return getStringLiteral(T.getAsString(Policy));
496 llvm::raw_svector_ostream OS(Str);
501 switch (BT->getKind()) {
502 case BuiltinType::Bool:
505 case BuiltinType::Char_U:
506 case BuiltinType::UChar:
509 case BuiltinType::Char_S:
510 case BuiltinType::SChar:
521 if (Specifier.getConversionSpecifier().getKind() ==
522 analyze_printf::PrintfConversionSpecifier::sArg) {
529 Specifier.toString(OS);
534 Specifier.toString(OS);
539 if (T->isPointerType()) {
548 bool dumpUnnamedRecord(
const RecordDecl *RD,
Expr *E,
unsigned Depth) {
549 Expr *IndentLit = getIndentString(Depth);
551 if (IndentLit ? callPrintFunction(
"%s%s", {IndentLit, TypeLit})
552 : callPrintFunction(
"%s", {TypeLit}))
555 return dumpRecordValue(RD, E, IndentLit, Depth);
568 Expr *RecordArg = makeOpaqueValueExpr(E);
571 if (callPrintFunction(
" {\n"))
575 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
576 for (
const auto &
Base : CXXRD->bases()) {
584 dumpUnnamedRecord(
Base.getType()->getAsRecordDecl(), BasePtr.
get(),
590 Expr *FieldIndentArg = getIndentString(Depth + 1);
593 for (
auto *D : RD->
decls()) {
594 auto *IFD = dyn_cast<IndirectFieldDecl>(D);
595 auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
596 if (!FD || FD->isUnnamedBitfield() || FD->isAnonymousStructOrUnion())
602 getStringLiteral(FD->getName())};
604 if (FD->isBitField()) {
608 FD->getBitWidthValue(S.
Context));
622 if (
Field.isInvalid())
625 auto *InnerRD = FD->getType()->getAsRecordDecl();
626 auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
627 if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
629 if (callPrintFunction(Format, Args) ||
630 dumpRecordValue(InnerRD,
Field.get(), FieldIndentArg, Depth + 1))
634 if (appendFormatSpecifier(FD->getType(), Format)) {
636 Args.push_back(
Field.get());
646 Args.push_back(FieldAddr.
get());
649 if (callPrintFunction(Format, Args))
654 return RecordIndent ? callPrintFunction(
"%s}\n", RecordIndent)
655 : callPrintFunction(
"}\n");
658 Expr *buildWrapper() {
661 TheCall->
setType(Wrapper->getType());
682 diag::err_expected_struct_pointer_argument)
695 switch (BT ? BT->getKind() : BuiltinType::Void) {
696 case BuiltinType::Dependent:
697 case BuiltinType::Overload:
698 case BuiltinType::BoundMember:
699 case BuiltinType::PseudoObject:
700 case BuiltinType::UnknownAny:
701 case BuiltinType::BuiltinFn:
707 diag::err_expected_callable_argument)
713 BuiltinDumpStructGenerator Generator(S, TheCall);
719 Expr *PtrArg = PtrArgResult.
get();
723 if (Generator.dumpUnnamedRecord(RD, PtrArg, 0))
726 return Generator.buildWrapper();
738 if (Call->getStmtClass() != Stmt::CallExprClass) {
739 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)
740 << Call->getSourceRange();
745 if (CE->getCallee()->getType()->isBlockPointerType()) {
746 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)
747 << Call->getSourceRange();
751 const Decl *TargetDecl = CE->getCalleeDecl();
752 if (
const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
753 if (FD->getBuiltinID()) {
754 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)
755 << Call->getSourceRange();
759 if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {
760 S.
Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)
761 << Call->getSourceRange();
769 S.
Diag(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)
783 BuiltinCall->
setType(CE->getType());
787 BuiltinCall->
setArg(1, ChainResult.
get());
794class ScanfDiagnosticFormatHandler
798 using ComputeSizeFunction =
799 llvm::function_ref<std::optional<llvm::APSInt>(
unsigned)>;
803 using DiagnoseFunction =
804 llvm::function_ref<void(
unsigned,
unsigned,
unsigned)>;
806 ComputeSizeFunction ComputeSizeArgument;
807 DiagnoseFunction Diagnose;
810 ScanfDiagnosticFormatHandler(ComputeSizeFunction ComputeSizeArgument,
811 DiagnoseFunction Diagnose)
812 : ComputeSizeArgument(ComputeSizeArgument), Diagnose(Diagnose) {}
815 const char *StartSpecifier,
816 unsigned specifierLen)
override {
817 if (!FS.consumesDataArgument())
820 unsigned NulByte = 0;
821 switch ((FS.getConversionSpecifier().getKind())) {
834 analyze_format_string::OptionalAmount::HowSpecified::Constant)
839 std::optional<llvm::APSInt> DestSizeAPS =
840 ComputeSizeArgument(FS.getArgIndex());
844 unsigned DestSize = DestSizeAPS->getZExtValue();
846 if (DestSize < SourceSize)
847 Diagnose(FS.getArgIndex(), DestSize, SourceSize);
853class EstimateSizeFormatHandler
858 EstimateSizeFormatHandler(StringRef Format)
859 :
Size(
std::
min(Format.find(0), Format.size()) +
863 const char *,
unsigned SpecifierLen,
866 const size_t FieldWidth = computeFieldWidth(FS);
867 const size_t Precision = computePrecision(FS);
870 switch (FS.getConversionSpecifier().getKind()) {
874 Size += std::max(FieldWidth, (
size_t)1);
886 Size += std::max(FieldWidth, Precision);
897 Size += std::max(FieldWidth, 1 +
898 (Precision ? 1 + Precision
908 (Precision ? 1 + Precision : 0) +
918 (Precision ? 1 + Precision : 0) +
930 Size += std::max(FieldWidth, 2 + Precision);
942 Size += FS.hasPlusPrefix() || FS.hasSpacePrefix();
944 if (FS.hasAlternativeForm()) {
945 switch (FS.getConversionSpecifier().getKind()) {
966 Size += (Precision ? 0 : 1);
970 assert(SpecifierLen <= Size &&
"no underflow");
971 Size -= SpecifierLen;
975 size_t getSizeLowerBound()
const {
return Size; }
980 size_t FieldWidth = 0;
988 size_t Precision = 0;
993 switch (FS.getConversionSpecifier().getKind()) {
1034void Sema::checkFortifiedBuiltinMemoryFunction(
FunctionDecl *FD,
1040 bool UseDABAttr =
false;
1043 const auto *DABAttr = FD->
getAttr<DiagnoseAsBuiltinAttr>();
1045 UseDecl = DABAttr->getFunction();
1046 assert(UseDecl &&
"Missing FunctionDecl in DiagnoseAsBuiltin attribute!");
1058 auto TranslateIndex = [&](
unsigned Index) -> std::optional<unsigned> {
1065 unsigned DABIndices = DABAttr->argIndices_size();
1066 unsigned NewIndex = Index < DABIndices
1067 ? DABAttr->argIndices_begin()[Index]
1070 return std::nullopt;
1074 auto ComputeExplicitObjectSizeArgument =
1075 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1076 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1078 return std::nullopt;
1079 unsigned NewIndex = *IndexOptional;
1083 return std::nullopt;
1089 auto ComputeSizeArgument =
1090 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1096 if (Index < FD->getNumParams()) {
1097 if (
const auto *POS =
1099 BOSType = POS->getType();
1102 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1104 return std::nullopt;
1105 unsigned NewIndex = *IndexOptional;
1108 return std::nullopt;
1110 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1113 return std::nullopt;
1116 return llvm::APSInt::getUnsigned(
Result).extOrTrunc(SizeTypeWidth);
1119 auto ComputeStrLenArgument =
1120 [&](
unsigned Index) -> std::optional<llvm::APSInt> {
1121 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1123 return std::nullopt;
1124 unsigned NewIndex = *IndexOptional;
1126 const Expr *ObjArg = TheCall->
getArg(NewIndex);
1129 return std::nullopt;
1131 return llvm::APSInt::getUnsigned(
Result + 1).extOrTrunc(SizeTypeWidth);
1134 std::optional<llvm::APSInt> SourceSize;
1135 std::optional<llvm::APSInt> DestinationSize;
1136 unsigned DiagID = 0;
1137 bool IsChkVariant =
false;
1139 auto GetFunctionName = [&]() {
1145 FunctionName = FunctionName.drop_front(std::strlen(
"__builtin___"));
1146 FunctionName = FunctionName.drop_back(std::strlen(
"_chk"));
1147 }
else if (FunctionName.startswith(
"__builtin_")) {
1148 FunctionName = FunctionName.drop_front(std::strlen(
"__builtin_"));
1150 return FunctionName;
1153 switch (BuiltinID) {
1156 case Builtin::BI__builtin_strcpy:
1157 case Builtin::BIstrcpy: {
1158 DiagID = diag::warn_fortify_strlen_overflow;
1159 SourceSize = ComputeStrLenArgument(1);
1160 DestinationSize = ComputeSizeArgument(0);
1164 case Builtin::BI__builtin___strcpy_chk: {
1165 DiagID = diag::warn_fortify_strlen_overflow;
1166 SourceSize = ComputeStrLenArgument(1);
1167 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1168 IsChkVariant =
true;
1172 case Builtin::BIscanf:
1173 case Builtin::BIfscanf:
1174 case Builtin::BIsscanf: {
1175 unsigned FormatIndex = 1;
1176 unsigned DataIndex = 2;
1177 if (BuiltinID == Builtin::BIscanf) {
1182 const auto *FormatExpr =
1185 const auto *Format = dyn_cast<StringLiteral>(FormatExpr);
1189 if (!Format->isOrdinary() && !Format->isUTF8())
1192 auto Diagnose = [&](
unsigned ArgIndex,
unsigned DestSize,
1193 unsigned SourceSize) {
1194 DiagID = diag::warn_fortify_scanf_overflow;
1195 unsigned Index = ArgIndex + DataIndex;
1196 StringRef FunctionName = GetFunctionName();
1198 PDiag(DiagID) << FunctionName << (Index + 1)
1199 << DestSize << SourceSize);
1202 StringRef FormatStrRef = Format->getString();
1203 auto ShiftedComputeSizeArgument = [&](
unsigned Index) {
1204 return ComputeSizeArgument(Index + DataIndex);
1206 ScanfDiagnosticFormatHandler H(ShiftedComputeSizeArgument,
Diagnose);
1207 const char *FormatBytes = FormatStrRef.data();
1210 assert(T &&
"String literal not of constant array type!");
1211 size_t TypeSize = T->getSize().getZExtValue();
1215 std::min(std::max(TypeSize,
size_t(1)) - 1, FormatStrRef.find(0));
1227 case Builtin::BIsprintf:
1228 case Builtin::BI__builtin___sprintf_chk: {
1229 size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
1232 if (
auto *Format = dyn_cast<StringLiteral>(FormatExpr)) {
1234 if (!Format->isOrdinary() && !Format->isUTF8())
1237 StringRef FormatStrRef = Format->getString();
1238 EstimateSizeFormatHandler H(FormatStrRef);
1239 const char *FormatBytes = FormatStrRef.data();
1242 assert(T &&
"String literal not of constant array type!");
1243 size_t TypeSize = T->getSize().getZExtValue();
1247 std::min(std::max(TypeSize,
size_t(1)) - 1, FormatStrRef.find(0));
1249 H, FormatBytes, FormatBytes + StrLen,
getLangOpts(),
1251 DiagID = diag::warn_fortify_source_format_overflow;
1252 SourceSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1253 .extOrTrunc(SizeTypeWidth);
1254 if (BuiltinID == Builtin::BI__builtin___sprintf_chk) {
1255 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1256 IsChkVariant =
true;
1258 DestinationSize = ComputeSizeArgument(0);
1265 case Builtin::BI__builtin___memcpy_chk:
1266 case Builtin::BI__builtin___memmove_chk:
1267 case Builtin::BI__builtin___memset_chk:
1268 case Builtin::BI__builtin___strlcat_chk:
1269 case Builtin::BI__builtin___strlcpy_chk:
1270 case Builtin::BI__builtin___strncat_chk:
1271 case Builtin::BI__builtin___strncpy_chk:
1272 case Builtin::BI__builtin___stpncpy_chk:
1273 case Builtin::BI__builtin___memccpy_chk:
1274 case Builtin::BI__builtin___mempcpy_chk: {
1275 DiagID = diag::warn_builtin_chk_overflow;
1276 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 2);
1278 ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1279 IsChkVariant =
true;
1283 case Builtin::BI__builtin___snprintf_chk:
1284 case Builtin::BI__builtin___vsnprintf_chk: {
1285 DiagID = diag::warn_builtin_chk_overflow;
1286 SourceSize = ComputeExplicitObjectSizeArgument(1);
1287 DestinationSize = ComputeExplicitObjectSizeArgument(3);
1288 IsChkVariant =
true;
1292 case Builtin::BIstrncat:
1293 case Builtin::BI__builtin_strncat:
1294 case Builtin::BIstrncpy:
1295 case Builtin::BI__builtin_strncpy:
1296 case Builtin::BIstpncpy:
1297 case Builtin::BI__builtin_stpncpy: {
1303 DiagID = diag::warn_fortify_source_size_mismatch;
1304 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1305 DestinationSize = ComputeSizeArgument(0);
1309 case Builtin::BImemcpy:
1310 case Builtin::BI__builtin_memcpy:
1311 case Builtin::BImemmove:
1312 case Builtin::BI__builtin_memmove:
1313 case Builtin::BImemset:
1314 case Builtin::BI__builtin_memset:
1315 case Builtin::BImempcpy:
1316 case Builtin::BI__builtin_mempcpy: {
1317 DiagID = diag::warn_fortify_source_overflow;
1318 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->
getNumArgs() - 1);
1319 DestinationSize = ComputeSizeArgument(0);
1322 case Builtin::BIsnprintf:
1323 case Builtin::BI__builtin_snprintf:
1324 case Builtin::BIvsnprintf:
1325 case Builtin::BI__builtin_vsnprintf: {
1326 DiagID = diag::warn_fortify_source_size_mismatch;
1327 SourceSize = ComputeExplicitObjectSizeArgument(1);
1328 DestinationSize = ComputeSizeArgument(0);
1333 if (!SourceSize || !DestinationSize ||
1334 llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)
1337 StringRef FunctionName = GetFunctionName();
1341 DestinationSize->toString(DestinationStr, 10);
1342 SourceSize->toString(SourceStr, 10);
1345 << FunctionName << DestinationStr << SourceStr);
1358 while (S && !S->isSEHExceptScope())
1360 if (!S || !(S->getFlags() & NeededScopeFlags)) {
1363 << DRE->getDecl()->getIdentifier();
1381 unsigned ArgCounter = 0;
1382 bool IllegalParams =
false;
1386 I != E; ++I, ++ArgCounter) {
1387 if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
1388 (*I)->getPointeeType().getQualifiers().getAddressSpace() !=
1394 if (isa<BlockExpr>(BlockArg)) {
1397 }
else if (isa<DeclRefExpr>(BlockArg)) {
1401 diag::err_opencl_enqueue_kernel_blocks_non_local_void_args);
1402 IllegalParams =
true;
1406 return IllegalParams;
1416 S.
Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
1417 << 1 << Call->getDirectCallee()
1418 <<
"cl_khr_subgroups or __opencl_c_subgroups";
1434 S.
Diag(NDRangeArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1441 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1457 S.
Diag(BlockArg->
getBeginLoc(), diag::err_opencl_builtin_expected_type)
1469 unsigned Start,
unsigned End) {
1470 bool IllegalParams =
false;
1471 for (
unsigned I = Start; I <= End; ++I)
1474 return IllegalParams;
1481 unsigned NumNonVarArgs) {
1484 unsigned NumBlockParams =
1486 unsigned TotalNumArgs = TheCall->
getNumArgs();
1490 if (TotalNumArgs != NumBlockParams + NumNonVarArgs) {
1492 diag::err_opencl_enqueue_kernel_local_size_args);
1532 diag::err_typecheck_call_too_few_args_at_least)
1533 << 0 << 4 << NumArgs;
1545 diag::err_opencl_builtin_expected_type)
1553 diag::err_opencl_builtin_expected_type)
1554 << TheCall->
getDirectCallee() <<
"'kernel_enqueue_flags_t' (i.e. uint)";
1561 diag::err_opencl_builtin_expected_type)
1580 diag::err_opencl_enqueue_kernel_blocks_no_args);
1604 diag::err_opencl_builtin_expected_type)
1617 diag::err_opencl_builtin_expected_type)
1629 diag::err_opencl_builtin_expected_type)
1643 diag::err_opencl_enqueue_kernel_incorrect_args);
1649 return D->
getAttr<OpenCLAccessAttr>();
1654 const Expr *Arg0 = Call->getArg(0);
1657 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1661 OpenCLAccessAttr *AccessQual =
1667 switch (Call->getDirectCallee()->getBuiltinID()) {
1668 case Builtin::BIread_pipe:
1669 case Builtin::BIreserve_read_pipe:
1670 case Builtin::BIcommit_read_pipe:
1671 case Builtin::BIwork_group_reserve_read_pipe:
1672 case Builtin::BIsub_group_reserve_read_pipe:
1673 case Builtin::BIwork_group_commit_read_pipe:
1674 case Builtin::BIsub_group_commit_read_pipe:
1675 if (!(!AccessQual || AccessQual->isReadOnly())) {
1677 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1682 case Builtin::BIwrite_pipe:
1683 case Builtin::BIreserve_write_pipe:
1684 case Builtin::BIcommit_write_pipe:
1685 case Builtin::BIwork_group_reserve_write_pipe:
1686 case Builtin::BIsub_group_reserve_write_pipe:
1687 case Builtin::BIwork_group_commit_write_pipe:
1688 case Builtin::BIsub_group_commit_write_pipe:
1689 if (!(AccessQual && AccessQual->isWriteOnly())) {
1691 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1704 const Expr *Arg0 = Call->getArg(0);
1705 const Expr *ArgIdx = Call->getArg(Idx);
1714 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1729 switch (Call->getNumArgs()) {
1746 if (!Call->getArg(1)->getType()->isReserveIDT()) {
1747 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1749 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1754 const Expr *Arg2 = Call->getArg(2);
1757 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1768 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_arg_num)
1769 << Call->getDirectCallee() << Call->getSourceRange();
1789 if (!Call->getArg(1)->getType()->isIntegerType() &&
1790 !Call->getArg(1)->getType()->isUnsignedIntegerType()) {
1791 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1793 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1818 if (!Call->getArg(1)->getType()->isReserveIDT()) {
1819 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1821 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1837 if (!Call->getArg(0)->getType()->isPipeType()) {
1838 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1839 << Call->getDirectCallee() << Call->getArg(0)->getSourceRange();
1857 auto RT = Call->getArg(0)->getType();
1858 if (!RT->isPointerType() || RT->getPointeeType()
1860 S.
Diag(Call->getBeginLoc(), diag::err_opencl_builtin_to_addr_invalid_arg)
1861 << Call->getArg(0) << Call->getDirectCallee() << Call->getSourceRange();
1866 S.
Diag(Call->getArg(0)->getBeginLoc(),
1867 diag::warn_opencl_generic_address_space_arg)
1868 << Call->getDirectCallee()->getNameInfo().getAsString()
1869 << Call->getArg(0)->getSourceRange();
1872 RT = RT->getPointeeType();
1873 auto Qual = RT.getQualifiers();
1874 switch (BuiltinID) {
1875 case Builtin::BIto_global:
1878 case Builtin::BIto_local:
1881 case Builtin::BIto_private:
1885 llvm_unreachable(
"Invalid builtin function");
1888 RT.getUnqualifiedType(), Qual)));
1914 auto DiagSelect = [&]() -> std::optional<unsigned> {
1921 return std::optional<unsigned>{};
1936 diag::err_incomplete_type))
1940 "Unhandled non-object pointer case");
1958 llvm::Triple::ObjectFormatType CurObjFormat =
1960 if (llvm::is_contained(UnsupportedObjectFormatTypes, CurObjFormat)) {
1973 llvm::Triple::ArchType CurArch =
1975 if (llvm::is_contained(SupportedArchs, CurArch))
1985bool Sema::CheckTSBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
1992 case llvm::Triple::arm:
1993 case llvm::Triple::armeb:
1994 case llvm::Triple::thumb:
1995 case llvm::Triple::thumbeb:
1996 return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
1997 case llvm::Triple::aarch64:
1998 case llvm::Triple::aarch64_32:
1999 case llvm::Triple::aarch64_be:
2000 return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
2001 case llvm::Triple::bpfeb:
2002 case llvm::Triple::bpfel:
2003 return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
2004 case llvm::Triple::hexagon:
2005 return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
2006 case llvm::Triple::mips:
2007 case llvm::Triple::mipsel:
2008 case llvm::Triple::mips64:
2009 case llvm::Triple::mips64el:
2010 return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
2011 case llvm::Triple::systemz:
2012 return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
2013 case llvm::Triple::x86:
2014 case llvm::Triple::x86_64:
2015 return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
2016 case llvm::Triple::ppc:
2017 case llvm::Triple::ppcle:
2018 case llvm::Triple::ppc64:
2019 case llvm::Triple::ppc64le:
2020 return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
2021 case llvm::Triple::amdgcn:
2022 return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
2023 case llvm::Triple::riscv32:
2024 case llvm::Triple::riscv64:
2025 return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
2026 case llvm::Triple::loongarch32:
2027 case llvm::Triple::loongarch64:
2028 return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
2029 case llvm::Triple::wasm32:
2030 case llvm::Triple::wasm64:
2031 return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
2032 case llvm::Triple::nvptx:
2033 case llvm::Triple::nvptx64:
2034 return CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
2044 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2055 EltTy = VecTy->getElementType();
2058 return S.
Diag(Loc, diag::err_builtin_invalid_arg_type)
2059 << ArgIndex << 5 << ArgTy;
2066Sema::CheckBuiltinFunctionCall(
FunctionDecl *FDecl,
unsigned BuiltinID,
2071 unsigned ICEArguments = 0;
2078 for (
unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
2080 if ((ICEArguments & (1 << ArgNo)) == 0)
continue;
2085 if (ArgNo < TheCall->getNumArgs() &&
2086 SemaBuiltinConstantArg(TheCall, ArgNo,
Result))
2088 ICEArguments &= ~(1 << ArgNo);
2091 switch (BuiltinID) {
2092 case Builtin::BI__builtin___CFStringMakeConstantString:
2096 *
this, BuiltinID, TheCall,
2097 {llvm::Triple::GOFF, llvm::Triple::XCOFF}))
2100 "Wrong # arguments to builtin CFStringMakeConstantString");
2101 if (CheckObjCString(TheCall->
getArg(0)))
2104 case Builtin::BI__builtin_ms_va_start:
2105 case Builtin::BI__builtin_stdarg_start:
2106 case Builtin::BI__builtin_va_start:
2107 if (SemaBuiltinVAStart(BuiltinID, TheCall))
2110 case Builtin::BI__va_start: {
2112 case llvm::Triple::aarch64:
2113 case llvm::Triple::arm:
2114 case llvm::Triple::thumb:
2115 if (SemaBuiltinVAStartARMMicrosoft(TheCall))
2119 if (SemaBuiltinVAStart(BuiltinID, TheCall))
2127 case Builtin::BI_interlockedbittestandset_acq:
2128 case Builtin::BI_interlockedbittestandset_rel:
2129 case Builtin::BI_interlockedbittestandset_nf:
2130 case Builtin::BI_interlockedbittestandreset_acq:
2131 case Builtin::BI_interlockedbittestandreset_rel:
2132 case Builtin::BI_interlockedbittestandreset_nf:
2134 *
this, BuiltinID, TheCall,
2135 {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
2140 case Builtin::BI_bittest64:
2141 case Builtin::BI_bittestandcomplement64:
2142 case Builtin::BI_bittestandreset64:
2143 case Builtin::BI_bittestandset64:
2144 case Builtin::BI_interlockedbittestandreset64:
2145 case Builtin::BI_interlockedbittestandset64:
2147 {llvm::Triple::x86_64, llvm::Triple::arm,
2148 llvm::Triple::thumb,
2149 llvm::Triple::aarch64}))
2153 case Builtin::BI__builtin_set_flt_rounds:
2155 {llvm::Triple::x86, llvm::Triple::x86_64,
2156 llvm::Triple::arm, llvm::Triple::thumb,
2157 llvm::Triple::aarch64}))
2161 case Builtin::BI__builtin_isgreater:
2162 case Builtin::BI__builtin_isgreaterequal:
2163 case Builtin::BI__builtin_isless:
2164 case Builtin::BI__builtin_islessequal:
2165 case Builtin::BI__builtin_islessgreater:
2166 case Builtin::BI__builtin_isunordered:
2167 if (SemaBuiltinUnorderedCompare(TheCall))
2170 case Builtin::BI__builtin_fpclassify:
2171 if (SemaBuiltinFPClassification(TheCall, 6))
2174 case Builtin::BI__builtin_isfpclass:
2175 if (SemaBuiltinFPClassification(TheCall, 2))
2178 case Builtin::BI__builtin_isfinite:
2179 case Builtin::BI__builtin_isinf:
2180 case Builtin::BI__builtin_isinf_sign:
2181 case Builtin::BI__builtin_isnan:
2182 case Builtin::BI__builtin_isnormal:
2183 case Builtin::BI__builtin_signbit:
2184 case Builtin::BI__builtin_signbitf:
2185 case Builtin::BI__builtin_signbitl:
2186 if (SemaBuiltinFPClassification(TheCall, 1))
2189 case Builtin::BI__builtin_shufflevector:
2193 case Builtin::BI__builtin_prefetch:
2194 if (SemaBuiltinPrefetch(TheCall))
2197 case Builtin::BI__builtin_alloca_with_align:
2198 case Builtin::BI__builtin_alloca_with_align_uninitialized:
2199 if (SemaBuiltinAllocaWithAlign(TheCall))
2202 case Builtin::BI__builtin_alloca:
2203 case Builtin::BI__builtin_alloca_uninitialized:
2207 case Builtin::BI__arithmetic_fence:
2208 if (SemaBuiltinArithmeticFence(TheCall))
2211 case Builtin::BI__assume:
2212 case Builtin::BI__builtin_assume:
2213 if (SemaBuiltinAssume(TheCall))
2216 case Builtin::BI__builtin_assume_aligned:
2217 if (SemaBuiltinAssumeAligned(TheCall))
2220 case Builtin::BI__builtin_dynamic_object_size:
2221 case Builtin::BI__builtin_object_size:
2222 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
2225 case Builtin::BI__builtin_longjmp:
2226 if (SemaBuiltinLongjmp(TheCall))
2229 case Builtin::BI__builtin_setjmp:
2230 if (SemaBuiltinSetjmp(TheCall))
2233 case Builtin::BI__builtin_classify_type:
2237 case Builtin::BI__builtin_complex:
2238 if (SemaBuiltinComplex(TheCall))
2241 case Builtin::BI__builtin_constant_p: {
2249 case Builtin::BI__builtin_launder:
2251 case Builtin::BI__sync_fetch_and_add:
2252 case Builtin::BI__sync_fetch_and_add_1:
2253 case Builtin::BI__sync_fetch_and_add_2:
2254 case Builtin::BI__sync_fetch_and_add_4:
2255 case Builtin::BI__sync_fetch_and_add_8:
2256 case Builtin::BI__sync_fetch_and_add_16:
2257 case Builtin::BI__sync_fetch_and_sub:
2258 case Builtin::BI__sync_fetch_and_sub_1:
2259 case Builtin::BI__sync_fetch_and_sub_2:
2260 case Builtin::BI__sync_fetch_and_sub_4:
2261 case Builtin::BI__sync_fetch_and_sub_8:
2262 case Builtin::BI__sync_fetch_and_sub_16:
2263 case Builtin::BI__sync_fetch_and_or:
2264 case Builtin::BI__sync_fetch_and_or_1:
2265 case Builtin::BI__sync_fetch_and_or_2:
2266 case Builtin::BI__sync_fetch_and_or_4:
2267 case Builtin::BI__sync_fetch_and_or_8:
2268 case Builtin::BI__sync_fetch_and_or_16:
2269 case Builtin::BI__sync_fetch_and_and:
2270 case Builtin::BI__sync_fetch_and_and_1:
2271 case Builtin::BI__sync_fetch_and_and_2:
2272 case Builtin::BI__sync_fetch_and_and_4:
2273 case Builtin::BI__sync_fetch_and_and_8:
2274 case Builtin::BI__sync_fetch_and_and_16:
2275 case Builtin::BI__sync_fetch_and_xor:
2276 case Builtin::BI__sync_fetch_and_xor_1:
2277 case Builtin::BI__sync_fetch_and_xor_2:
2278 case Builtin::BI__sync_fetch_and_xor_4:
2279 case Builtin::BI__sync_fetch_and_xor_8:
2280 case Builtin::BI__sync_fetch_and_xor_16:
2281 case Builtin::BI__sync_fetch_and_nand:
2282 case Builtin::BI__sync_fetch_and_nand_1:
2283 case Builtin::BI__sync_fetch_and_nand_2:
2284 case Builtin::BI__sync_fetch_and_nand_4:
2285 case Builtin::BI__sync_fetch_and_nand_8:
2286 case Builtin::BI__sync_fetch_and_nand_16:
2287 case Builtin::BI__sync_add_and_fetch:
2288 case Builtin::BI__sync_add_and_fetch_1:
2289 case Builtin::BI__sync_add_and_fetch_2:
2290 case Builtin::BI__sync_add_and_fetch_4:
2291 case Builtin::BI__sync_add_and_fetch_8:
2292 case Builtin::BI__sync_add_and_fetch_16:
2293 case Builtin::BI__sync_sub_and_fetch:
2294 case Builtin::BI__sync_sub_and_fetch_1:
2295 case Builtin::BI__sync_sub_and_fetch_2:
2296 case Builtin::BI__sync_sub_and_fetch_4:
2297 case Builtin::BI__sync_sub_and_fetch_8:
2298 case Builtin::BI__sync_sub_and_fetch_16:
2299 case Builtin::BI__sync_and_and_fetch:
2300 case Builtin::BI__sync_and_and_fetch_1:
2301 case Builtin::BI__sync_and_and_fetch_2:
2302 case Builtin::BI__sync_and_and_fetch_4:
2303 case Builtin::BI__sync_and_and_fetch_8:
2304 case Builtin::BI__sync_and_and_fetch_16:
2305 case Builtin::BI__sync_or_and_fetch:
2306 case Builtin::BI__sync_or_and_fetch_1:
2307 case Builtin::BI__sync_or_and_fetch_2:
2308 case Builtin::BI__sync_or_and_fetch_4:
2309 case Builtin::BI__sync_or_and_fetch_8:
2310 case Builtin::BI__sync_or_and_fetch_16:
2311 case Builtin::BI__sync_xor_and_fetch:
2312 case Builtin::BI__sync_xor_and_fetch_1:
2313 case Builtin::BI__sync_xor_and_fetch_2:
2314 case Builtin::BI__sync_xor_and_fetch_4:
2315 case Builtin::BI__sync_xor_and_fetch_8:
2316 case Builtin::BI__sync_xor_and_fetch_16:
2317 case Builtin::BI__sync_nand_and_fetch:
2318 case Builtin::BI__sync_nand_and_fetch_1:
2319 case Builtin::BI__sync_nand_and_fetch_2:
2320 case Builtin::BI__sync_nand_and_fetch_4:
2321 case Builtin::BI__sync_nand_and_fetch_8:
2322 case Builtin::BI__sync_nand_and_fetch_16:
2323 case Builtin::BI__sync_val_compare_and_swap:
2324 case Builtin::BI__sync_val_compare_and_swap_1:
2325 case Builtin::BI__sync_val_compare_and_swap_2:
2326 case Builtin::BI__sync_val_compare_and_swap_4:
2327 case Builtin::BI__sync_val_compare_and_swap_8:
2328 case Builtin::BI__sync_val_compare_and_swap_16:
2329 case Builtin::BI__sync_bool_compare_and_swap:
2330 case Builtin::BI__sync_bool_compare_and_swap_1:
2331 case Builtin::BI__sync_bool_compare_and_swap_2:
2332 case Builtin::BI__sync_bool_compare_and_swap_4:
2333 case Builtin::BI__sync_bool_compare_and_swap_8:
2334 case Builtin::BI__sync_bool_compare_and_swap_16:
2335 case Builtin::BI__sync_lock_test_and_set:
2336 case Builtin::BI__sync_lock_test_and_set_1:
2337 case Builtin::BI__sync_lock_test_and_set_2:
2338 case Builtin::BI__sync_lock_test_and_set_4:
2339 case Builtin::BI__sync_lock_test_and_set_8:
2340 case Builtin::BI__sync_lock_test_and_set_16:
2341 case Builtin::BI__sync_lock_release:
2342 case Builtin::BI__sync_lock_release_1:
2343 case Builtin::BI__sync_lock_release_2:
2344 case Builtin::BI__sync_lock_release_4:
2345 case Builtin::BI__sync_lock_release_8:
2346 case Builtin::BI__sync_lock_release_16:
2347 case Builtin::BI__sync_swap:
2348 case Builtin::BI__sync_swap_1:
2349 case Builtin::BI__sync_swap_2:
2350 case Builtin::BI__sync_swap_4:
2351 case Builtin::BI__sync_swap_8:
2352 case Builtin::BI__sync_swap_16:
2353 return SemaBuiltinAtomicOverloaded(TheCallResult);
2354 case Builtin::BI__sync_synchronize:
2358 case Builtin::BI__builtin_nontemporal_load:
2359 case Builtin::BI__builtin_nontemporal_store:
2360 return SemaBuiltinNontemporalOverloaded(TheCallResult);
2361 case Builtin::BI__builtin_memcpy_inline: {
2374 case Builtin::BI__builtin_memset_inline: {
2385#define BUILTIN(ID, TYPE, ATTRS)
2386#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
2387 case Builtin::BI##ID: \
2388 return SemaAtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
2389#include "clang/Basic/Builtins.def"
2390 case Builtin::BI__annotation:
2394 case Builtin::BI__builtin_annotation:
2398 case Builtin::BI__builtin_addressof:
2402 case Builtin::BI__builtin_function_start:
2406 case Builtin::BI__builtin_is_aligned:
2407 case Builtin::BI__builtin_align_up:
2408 case Builtin::BI__builtin_align_down:
2412 case Builtin::BI__builtin_add_overflow:
2413 case Builtin::BI__builtin_sub_overflow:
2414 case Builtin::BI__builtin_mul_overflow:
2418 case Builtin::BI__builtin_operator_new:
2419 case Builtin::BI__builtin_operator_delete: {
2420 bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
2422 SemaBuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
2427 case Builtin::BI__builtin_dump_struct:
2429 case Builtin::BI__builtin_expect_with_probability: {
2440 Diag(ProbArg->
getBeginLoc(), diag::err_probability_not_constant_float)
2447 bool LoseInfo =
false;
2448 Probability.convert(llvm::APFloat::IEEEdouble(),
2449 llvm::RoundingMode::Dynamic, &LoseInfo);
2450 if (!(Probability >= llvm::APFloat(0.0) &&
2451 Probability <= llvm::APFloat(1.0))) {
2458 case Builtin::BI__builtin_preserve_access_index:
2462 case Builtin::BI__builtin_call_with_static_chain:
2466 case Builtin::BI__exception_code:
2467 case Builtin::BI_exception_code:
2469 diag::err_seh___except_block))
2472 case Builtin::BI__exception_info:
2473 case Builtin::BI_exception_info:
2475 diag::err_seh___except_filter))
2478 case Builtin::BI__GetExceptionInfo:
2490 case Builtin::BIaddressof:
2491 case Builtin::BI__addressof:
2492 case Builtin::BIforward:
2493 case Builtin::BIforward_like:
2494 case Builtin::BImove:
2495 case Builtin::BImove_if_noexcept:
2496 case Builtin::BIas_const: {
2504 bool ReturnsPointer = BuiltinID == Builtin::BIaddressof ||
2505 BuiltinID == Builtin::BI__addressof;
2506 if (!(Param->isReferenceType() &&
2507 (ReturnsPointer ?
Result->isAnyPointerType()
2508 :
Result->isReferenceType()) &&
2510 Result->getPointeeType()))) {
2511 Diag(TheCall->
getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2518 case Builtin::BIread_pipe:
2519 case Builtin::BIwrite_pipe:
2525 case Builtin::BIreserve_read_pipe:
2526 case Builtin::BIreserve_write_pipe:
2527 case Builtin::BIwork_group_reserve_read_pipe:
2528 case Builtin::BIwork_group_reserve_write_pipe:
2532 case Builtin::BIsub_group_reserve_read_pipe:
2533 case Builtin::BIsub_group_reserve_write_pipe:
2538 case Builtin::BIcommit_read_pipe:
2539 case Builtin::BIcommit_write_pipe:
2540 case Builtin::BIwork_group_commit_read_pipe:
2541 case Builtin::BIwork_group_commit_write_pipe:
2545 case Builtin::BIsub_group_commit_read_pipe:
2546 case Builtin::BIsub_group_commit_write_pipe:
2551 case Builtin::BIget_pipe_num_packets:
2552 case Builtin::BIget_pipe_max_packets:
2556 case Builtin::BIto_global:
2557 case Builtin::BIto_local:
2558 case Builtin::BIto_private:
2563 case Builtin::BIenqueue_kernel:
2567 case Builtin::BIget_kernel_work_group_size:
2568 case Builtin::BIget_kernel_preferred_work_group_size_multiple:
2572 case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
2573 case Builtin::BIget_kernel_sub_group_count_for_ndrange:
2577 case Builtin::BI__builtin_os_log_format:
2578 Cleanup.setExprNeedsCleanups(
true);
2580 case Builtin::BI__builtin_os_log_format_buffer_size:
2581 if (SemaBuiltinOSLogFormat(TheCall))
2584 case Builtin::BI__builtin_frame_address:
2585 case Builtin::BI__builtin_return_address: {
2586 if (SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
2594 Result.Val.getInt() != 0)
2596 << ((BuiltinID == Builtin::BI__builtin_return_address)
2597 ?
"__builtin_return_address"
2598 :
"__builtin_frame_address")
2603 case Builtin::BI__builtin_nondeterministic_value: {
2604 if (SemaBuiltinNonDeterministicValue(TheCall))
2611 case Builtin::BI__builtin_elementwise_abs: {
2612 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2619 EltTy = VecTy->getElementType();
2622 diag::err_builtin_invalid_arg_type)
2631 case Builtin::BI__builtin_elementwise_ceil:
2632 case Builtin::BI__builtin_elementwise_cos:
2633 case Builtin::BI__builtin_elementwise_exp:
2634 case Builtin::BI__builtin_elementwise_exp2:
2635 case Builtin::BI__builtin_elementwise_floor:
2636 case Builtin::BI__builtin_elementwise_log:
2637 case Builtin::BI__builtin_elementwise_log2:
2638 case Builtin::BI__builtin_elementwise_log10:
2639 case Builtin::BI__builtin_elementwise_roundeven:
2640 case Builtin::BI__builtin_elementwise_round:
2641 case Builtin::BI__builtin_elementwise_rint:
2642 case Builtin::BI__builtin_elementwise_nearbyint:
2643 case Builtin::BI__builtin_elementwise_sin:
2644 case Builtin::BI__builtin_elementwise_trunc:
2645 case Builtin::BI__builtin_elementwise_canonicalize: {
2646 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2655 case Builtin::BI__builtin_elementwise_fma: {
2656 if (SemaBuiltinElementwiseTernaryMath(TheCall))
2663 case Builtin::BI__builtin_elementwise_pow: {
2664 if (SemaBuiltinElementwiseMath(TheCall))
2678 case Builtin::BI__builtin_elementwise_add_sat:
2679 case Builtin::BI__builtin_elementwise_sub_sat: {
2680 if (SemaBuiltinElementwiseMath(TheCall))
2688 EltTy = VecTy->getElementType();
2698 case Builtin::BI__builtin_elementwise_min:
2699 case Builtin::BI__builtin_elementwise_max:
2700 if (SemaBuiltinElementwiseMath(TheCall))
2703 case Builtin::BI__builtin_elementwise_copysign: {
2723 diag::err_typecheck_call_different_arg_types)
2724 << MagnitudeTy << SignTy;
2732 case Builtin::BI__builtin_reduce_max:
2733 case Builtin::BI__builtin_reduce_min: {
2734 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2745 TheCall->
setType(TyA->getElementType());
2751 case Builtin::BI__builtin_reduce_add:
2752 case Builtin::BI__builtin_reduce_mul:
2753 case Builtin::BI__builtin_reduce_xor:
2754 case Builtin::BI__builtin_reduce_or:
2755 case Builtin::BI__builtin_reduce_and: {
2756 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2761 if (!TyA || !TyA->getElementType()->isIntegerType()) {
2766 TheCall->
setType(TyA->getElementType());
2770 case Builtin::BI__builtin_matrix_transpose:
2771 return SemaBuiltinMatrixTranspose(TheCall, TheCallResult);
2773 case Builtin::BI__builtin_matrix_column_major_load:
2774 return SemaBuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
2776 case Builtin::BI__builtin_matrix_column_major_store:
2777 return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
2779 case Builtin::BI__builtin_get_device_side_mangled_name: {
2780 auto Check = [](
CallExpr *TheCall) {
2786 auto *D = DRE->getDecl();
2787 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
2789 return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
2790 D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
2792 if (!Check(TheCall)) {
2794 diag::err_hip_invalid_args_builtin_mangled_name);
2805 "Aux Target Builtin, but not an aux target?");
2807 if (CheckTSBuiltinFunctionCall(
2818 return TheCallResult;
2822static unsigned RFT(
unsigned t,
bool shift =
false,
bool ForceQuad =
false) {
2824 int IsQuad = ForceQuad ?
true :
Type.isQuad();
2825 switch (
Type.getEltType()) {
2828 return shift ? 7 : (8 << IsQuad) - 1;
2831 return shift ? 15 : (4 << IsQuad) - 1;
2833 return shift ? 31 : (2 << IsQuad) - 1;
2836 return shift ? 63 : (1 << IsQuad) - 1;
2838 return shift ? 127 : (1 << IsQuad) - 1;
2840 assert(!shift &&
"cannot shift float types!");
2841 return (4 << IsQuad) - 1;
2843 assert(!shift &&
"cannot shift float types!");
2844 return (2 << IsQuad) - 1;
2846 assert(!shift &&
"cannot shift float types!");
2847 return (1 << IsQuad) - 1;
2849 assert(!shift &&
"cannot shift float types!");
2850 return (4 << IsQuad) - 1;
2852 llvm_unreachable(
"Invalid NeonTypeFlag!");
2859 bool IsPolyUnsigned,
bool IsInt64Long) {
2893 llvm_unreachable(
"Invalid NeonTypeFlag!");
2896bool Sema::CheckSVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
2900 switch (BuiltinID) {
2903#define GET_SVE_IMMEDIATE_CHECK
2904#include "clang/Basic/arm_sve_sema_rangechecks.inc"
2905#undef GET_SVE_IMMEDIATE_CHECK
2906#define GET_SME_IMMEDIATE_CHECK
2907#include "clang/Basic/arm_sme_sema_rangechecks.inc"
2908#undef GET_SME_IMMEDIATE_CHECK
2912 bool HasError =
false;
2913 for (
auto &I : ImmChecks) {
2914 int ArgNum, CheckTy, ElementSizeInBits;
2915 std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;
2917 typedef bool(*OptionSetCheckFnTy)(int64_t
Value);
2921 auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
2922 int ErrDiag) ->
bool {
2930 if (SemaBuiltinConstantArg(TheCall, ArgNum, Imm))
2933 if (!CheckImm(Imm.getSExtValue()))
2939 case SVETypeFlags::ImmCheck0_31:
2940 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
2943 case SVETypeFlags::ImmCheck0_13:
2944 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
2947 case SVETypeFlags::ImmCheck1_16:
2948 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
2951 case SVETypeFlags::ImmCheck0_7:
2952 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
2955 case SVETypeFlags::ImmCheckExtract:
2956 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2957 (2048 / ElementSizeInBits) - 1))
2960 case SVETypeFlags::ImmCheckShiftRight:
2961 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
2964 case SVETypeFlags::ImmCheckShiftRightNarrow:
2965 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1,
2966 ElementSizeInBits / 2))
2969 case SVETypeFlags::ImmCheckShiftLeft:
2970 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2971 ElementSizeInBits - 1))
2974 case SVETypeFlags::ImmCheckLaneIndex:
2975 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2976 (128 / (1 * ElementSizeInBits)) - 1))
2979 case SVETypeFlags::ImmCheckLaneIndexCompRotate:
2980 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2981 (128 / (2 * ElementSizeInBits)) - 1))
2984 case SVETypeFlags::ImmCheckLaneIndexDot:
2985 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
2986 (128 / (4 * ElementSizeInBits)) - 1))
2989 case SVETypeFlags::ImmCheckComplexRot90_270:
2990 if (CheckImmediateInSet([](int64_t
V) {
return V == 90 ||
V == 270; },
2991 diag::err_rotation_argument_to_cadd))
2994 case SVETypeFlags::ImmCheckComplexRotAll90:
2995 if (CheckImmediateInSet(
2997 return V == 0 ||
V == 90 ||
V == 180 ||
V == 270;
2999 diag::err_rotation_argument_to_cmla))
3002 case SVETypeFlags::ImmCheck0_1:
3003 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
3006 case SVETypeFlags::ImmCheck0_2:
3007 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
3010 case SVETypeFlags::ImmCheck0_3:
3011 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
3014 case SVETypeFlags::ImmCheck0_0:
3015 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 0))
3018 case SVETypeFlags::ImmCheck0_15:
3019 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 15))
3022 case SVETypeFlags::ImmCheck0_255:
3023 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 255))
3032bool Sema::CheckNeonBuiltinFunctionCall(
const TargetInfo &TI,
3033 unsigned BuiltinID,
CallExpr *TheCall) {
3038 bool HasConstPtr =
false;
3039 switch (BuiltinID) {
3040#define GET_NEON_OVERLOAD_CHECK
3041#include "clang/Basic/arm_neon.inc"
3042#include "clang/Basic/arm_fp16.inc"
3043#undef GET_NEON_OVERLOAD_CHECK
3050 if (SemaBuiltinConstantArg(TheCall, ImmArg,
Result))
3053 TV =
Result.getLimitedValue(64);
3054 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3059 if (PtrArgNum >= 0) {
3063 Arg = ICE->getSubExpr();
3067 llvm::Triple::ArchType Arch = TI.
getTriple().getArch();
3068 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3069 Arch == llvm::Triple::aarch64_32 ||
3070 Arch == llvm::Triple::aarch64_be;
3088 unsigned i = 0, l = 0, u = 0;
3089 switch (BuiltinID) {
3092 #define GET_NEON_IMMEDIATE_CHECK
3093 #include "clang/Basic/arm_neon.inc"
3094 #include "clang/Basic/arm_fp16.inc"
3095 #undef GET_NEON_IMMEDIATE_CHECK
3098 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
3101bool Sema::CheckMVEBuiltinFunctionCall(
unsigned BuiltinID,
CallExpr *TheCall) {
3102 switch (BuiltinID) {
3105 #include "clang/Basic/arm_mve_builtin_sema.inc"
3109bool Sema::CheckCDEBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3112 switch (BuiltinID) {
3115#include "clang/Basic/arm_cde_builtin_sema.inc"
3121 return CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
true);
3124bool Sema::CheckARMCoprocessorImmediate(
const TargetInfo &TI,
3125 const Expr *CoprocArg,
bool WantCDE) {
3134 int64_t CoprocNo = CoprocNoAP.getExtValue();
3135 assert(CoprocNo >= 0 &&
"Coprocessor immediate must be non-negative");
3138 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3140 if (IsCDECoproc != WantCDE)
3147bool Sema::CheckARMBuiltinExclusiveCall(
unsigned BuiltinID,
CallExpr *TheCall,
3148 unsigned MaxWidth) {
3149 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3150 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3151 BuiltinID == ARM::BI__builtin_arm_strex ||
3152 BuiltinID == ARM::BI__builtin_arm_stlex ||
3153 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3154 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3155 BuiltinID == AArch64::BI__builtin_arm_strex ||
3156 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3157 "unexpected ARM builtin");
3158 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3159 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3160 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3161 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3173 Expr *PointerArg = TheCall->
getArg(IsLdrex ? 0 : 1);
3177 PointerArg = PointerArgRes.
get();
3197 CastNeeded = CK_BitCast;
3198 Diag(DRE->
getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3208 PointerArg = PointerArgRes.
get();
3210 TheCall->
setArg(IsLdrex ? 0 : 1, PointerArg);
3215 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3222 assert(MaxWidth == 64 &&
"Diagnostic unexpectedly inaccurate");
3223 Diag(DRE->
getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3262bool Sema::CheckARMBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
3264 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3265 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3266 BuiltinID == ARM::BI__builtin_arm_strex ||
3267 BuiltinID == ARM::BI__builtin_arm_stlex) {
3268 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3271 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3272 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3273 SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
3276 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3277 BuiltinID == ARM::BI__builtin_arm_wsr64)
3278 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3,
false);
3280 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3281 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3282 BuiltinID == ARM::BI__builtin_arm_wsr ||
3283 BuiltinID == ARM::BI__builtin_arm_wsrp)
3284 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3286 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3288 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3290 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3296 switch (BuiltinID) {
3297 default:
return false;
3298 case ARM::BI__builtin_arm_ssat:
3299 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 32);
3300 case ARM::BI__builtin_arm_usat:
3301 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
3302 case ARM::BI__builtin_arm_ssat16:
3303 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
3304 case ARM::BI__builtin_arm_usat16:
3305 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
3306 case ARM::BI__builtin_arm_vcvtr_f:
3307 case ARM::BI__builtin_arm_vcvtr_d:
3308 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
3309 case ARM::BI__builtin_arm_dmb:
3310 case ARM::BI__builtin_arm_dsb:
3311 case ARM::BI__builtin_arm_isb:
3312 case ARM::BI__builtin_arm_dbg:
3313 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15);
3314 case ARM::BI__builtin_arm_cdp:
3315 case ARM::BI__builtin_arm_cdp2:
3316 case ARM::BI__builtin_arm_mcr:
3317 case ARM::BI__builtin_arm_mcr2:
3318 case ARM::BI__builtin_arm_mrc:
3319 case ARM::BI__builtin_arm_mrc2:
3320 case ARM::BI__builtin_arm_mcrr:
3321 case ARM::BI__builtin_arm_mcrr2:
3322 case ARM::BI__builtin_arm_mrrc:
3323 case ARM::BI__builtin_arm_mrrc2:
3324 case ARM::BI__builtin_arm_ldc:
3325 case ARM::BI__builtin_arm_ldcl:
3326 case ARM::BI__builtin_arm_ldc2:
3327 case ARM::BI__builtin_arm_ldc2l:
3328 case ARM::BI__builtin_arm_stc:
3329 case ARM::BI__builtin_arm_stcl:
3330 case ARM::BI__builtin_arm_stc2:
3331 case ARM::BI__builtin_arm_stc2l:
3332 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15) ||
3333 CheckARMCoprocessorImmediate(TI, TheCall->
getArg(0),
3338bool Sema::CheckAArch64BuiltinFunctionCall(
const TargetInfo &TI,
3341 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3342 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3343 BuiltinID == AArch64::BI__builtin_arm_strex ||
3344 BuiltinID == AArch64::BI__builtin_arm_stlex) {
3345 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
3348 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
3349 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3350 SemaBuiltinConstantArgRange(TheCall, 2, 0, 3) ||
3351 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
3352 SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
3355 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
3356 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
3357 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
3358 BuiltinID == AArch64::BI__builtin_arm_wsr128)
3359 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3362 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
3363 BuiltinID == AArch64::BI__builtin_arm_addg ||
3364 BuiltinID == AArch64::BI__builtin_arm_gmi ||
3365 BuiltinID == AArch64::BI__builtin_arm_ldg ||
3366 BuiltinID == AArch64::BI__builtin_arm_stg ||
3367 BuiltinID == AArch64::BI__builtin_arm_subp) {
3368 return SemaBuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
3371 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
3372 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
3373 BuiltinID == AArch64::BI__builtin_arm_wsr ||
3374 BuiltinID == AArch64::BI__builtin_arm_wsrp)
3375 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5,
true);
3380 if (BuiltinID == AArch64::BI_ReadStatusReg ||
3381 BuiltinID == AArch64::BI_WriteStatusReg)
3382 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
3384 if (BuiltinID == AArch64::BI__getReg)
3385 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
3387 if (BuiltinID == AArch64::BI__break)
3388 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
3390 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3393 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
3398 unsigned i = 0, l = 0, u = 0;
3399 switch (BuiltinID) {
3400 default:
return false;
3401 case AArch64::BI__builtin_arm_dmb:
3402 case AArch64::BI__builtin_arm_dsb:
3403 case AArch64::BI__builtin_arm_isb: l = 0; u = 15;
break;
3404 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535;
break;
3407 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
3425 if (ArgType->getAsPlaceholderType())
3443 if (
const auto *RT = Ty->
getAs<RecordType>()) {
3444 if (!RT->getDecl()->getDeclName().isEmpty())
3446 }
else if (
const auto *ET = Ty->
getAs<EnumType>()) {
3447 if (!ET->getDecl()->getDeclName().isEmpty())
3456 if (ArgType->getAsPlaceholderType())
3463 const auto *UO = dyn_cast<UnaryOperator>(Arg->
IgnoreParens());
3467 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
3470 if (CE->getCastKind() != CK_IntegralToPointer &&
3471 CE->getCastKind() != CK_NullToPointer)
3475 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
3480 dyn_cast<EnumConstantDecl>(DR->getDecl());
3486 const auto *ET = Ty->
getAs<EnumType>();
3491 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
3494bool Sema::CheckBPFBuiltinFunctionCall(
unsigned BuiltinID,
3496 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
3497 BuiltinID == BPF::BI__builtin_btf_type_id ||
3498 BuiltinID == BPF::BI__builtin_preserve_type_info ||
3499 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
3500 "unexpected BPF builtin");
3510 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
3511 kind = diag::err_preserve_field_info_not_const;
3512 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
3513 kind = diag::err_btf_type_id_not_const;
3514 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
3515 kind = diag::err_preserve_type_info_not_const;
3517 kind = diag::err_preserve_enum_value_not_const;
3523 Arg = TheCall->
getArg(0);
3524 bool InvalidArg =
false;
3525 bool ReturnUnsignedInt =
true;
3526 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
3529 kind = diag::err_preserve_field_info_not_field;
3531 }
else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
3534 kind = diag::err_preserve_type_info_invalid;
3536 }
else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
3539 kind = diag::err_preserve_enum_value_invalid;
3541 ReturnUnsignedInt =
false;
3542 }
else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
3543 ReturnUnsignedInt =
false;
3551 if (ReturnUnsignedInt)
3558bool Sema::CheckHexagonBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
3571 { Hexagon::BI__builtin_circ_ldd, {{ 3,
true, 4, 3 }} },
3572 { Hexagon::BI__builtin_circ_ldw, {{ 3,
true, 4, 2 }} },
3573 { Hexagon::BI__builtin_circ_ldh, {{ 3,
true, 4, 1 }} },
3574 { Hexagon::BI__builtin_circ_lduh, {{ 3,
true, 4, 1 }} },
3575 { Hexagon::BI__builtin_circ_ldb, {{ 3,
true, 4, 0 }} },
3576 { Hexagon::BI__builtin_circ_ldub, {{ 3,
true, 4, 0 }} },
3577 { Hexagon::BI__builtin_circ_std, {{ 3,
true, 4, 3 }} },
3578 { Hexagon::BI__builtin_circ_stw, {{ 3,
true, 4, 2 }} },
3579 { Hexagon::BI__builtin_circ_sth, {{ 3,
true, 4, 1 }} },
3580 { Hexagon::BI__builtin_circ_sthhi, {{ 3,
true, 4, 1 }} },
3581 { Hexagon::BI__builtin_circ_stb, {{ 3,
true, 4, 0 }} },
3583 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1,
true, 4, 0 }} },
3584 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1,
true, 4, 0 }} },
3585 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1,
true, 4, 1 }} },
3586 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1,
true, 4, 1 }} },
3587 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1,
true, 4, 2 }} },
3588 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1,
true, 4, 3 }} },
3589 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1,
true, 4, 0 }} },
3590 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1,
true, 4, 1 }} },
3591 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1,
true, 4, 1 }} },
3592 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1,
true, 4, 2 }} },
3593 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1,
true, 4, 3 }} },
3595 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1,
true, 8, 0 }} },
3596 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1,
false, 16, 0 }} },
3597 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1,
false, 16, 0 }} },
3598 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0,
true, 8, 0 }} },
3599 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1,
false, 5, 0 }} },
3600 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1,
false, 8, 0 }} },
3601 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1,
true, 8, 0 }} },
3602 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1,
false, 5, 0 }} },
3603 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1,
false, 5, 0 }} },
3604 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1,
false, 5, 0 }} },
3605 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1,
false, 8, 0 }} },
3606 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1,
true, 8, 0 }} },
3607 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1,
false, 7, 0 }} },
3608 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1,
true, 8, 0 }} },
3609 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1,
true, 8, 0 }} },
3610 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1,
false, 7, 0 }} },
3611 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1,
true, 8, 0 }} },
3612 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1,
true, 8, 0 }} },
3613 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1,
false, 7, 0 }} },
3614 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1,
false, 6, 0 }} },
3615 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2,
true, 8, 0 }} },
3616 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1,
false, 6, 0 }} },
3617 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1,
false, 5, 0 }} },
3618 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0,
false, 10, 0 }} },
3619 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0,
false, 10, 0 }} },
3620 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1,
false, 5, 0 }} },
3621 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0,
false, 10, 0 }} },
3622 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0,
false, 10, 0 }} },
3623 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2,
false, 6, 0 }} },
3624 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1,
false, 6, 2 }} },
3625 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2,
false, 3, 0 }} },
3626 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2,
false, 6, 0 }} },
3627 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2,
false, 6, 0 }} },
3628 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1,
false, 6, 0 }} },
3629 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2,
false, 6, 0 }} },
3630 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2,
false, 6, 0 }} },
3631 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2,
false, 6, 0 }} },
3632 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2,
false, 5, 0 }} },
3633 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2,
false, 5, 0 }} },
3634 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1,
false, 5, 0 }} },
3635 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2,
false, 5, 0 }} },
3636 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2,
false, 5, 0 }} },
3637 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1,
false, 5, 0 }} },
3638 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2,
false, 5, 0 }} },
3639 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1,
false, 4, 0 }} },
3640 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1,
false, 5, 0 }} },
3641 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2,
false, 6, 0 }} },
3642 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2,
false, 6, 0 }} },
3643 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1,
false, 6, 0 }} },
3644 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2,
false, 6, 0 }} },
3645 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2,
false, 6, 0 }} },
3646 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
3647 {{ 1,
false, 6, 0 }} },
3648 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1,
false, 6, 0 }} },
3649 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2,
false, 5, 0 }} },
3650 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2,
false, 5, 0 }} },
3651 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1,
false, 5, 0 }} },
3652 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2,
false, 5, 0 }} },
3653 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2,
false, 5, 0 }} },
3654 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
3655 {{ 1,
false, 5, 0 }} },
3656 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1,
false, 5, 0 }} },
3657 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1,
false, 5, 0 }} },
3658 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1,
false, 4, 0 }} },
3659 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1,
false, 5, 0 }} },
3660 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1,
false, 5, 0 }} },
3661 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1,
false, 5, 0 },
3662 { 2,
false, 5, 0 }} },
3663 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1,
false, 6, 0 },
3664 { 2,
false, 6, 0 }} },
3665 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2,
false, 5, 0 },
3666 { 3,
false, 5, 0 }} },
3667 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2,
false, 6, 0 },
3668 { 3,
false, 6, 0 }} },
3669 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2,
false, 6, 0 }} },
3670 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2,
false, 6, 0 }} },
3671 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1,
false, 6, 0 }} },
3672 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2,
false, 6, 0 }} },
3673 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2,
false, 6, 0 }} },
3674 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2,
false, 6, 0 }} },
3675 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2,
false, 5, 0 }} },
3676 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2,
false, 5, 0 }} },
3677 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1,
false, 5, 0 }} },
3678 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2,
false, 5, 0 }} },
3679 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2,
false, 5, 0 }} },
3680 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2,
false, 5, 0 }} },
3681 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1,
false, 4, 0 }} },
3682 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1,
false, 5, 0 }} },
3683 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1,
false, 5, 0 }} },
3684 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
3685 {{ 2,
false, 4, 0 },
3686 { 3,
false, 5, 0 }} },
3687 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
3688 {{ 2,
false, 4, 0 },
3689 { 3,
false, 5, 0 }} },
3690 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
3691 {{ 2,
false, 4, 0 },
3692 { 3,
false, 5, 0 }} },
3693 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
3694 {{ 2,
false, 4, 0 },
3695 { 3,
false, 5, 0 }} },
3696 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1,
false, 5, 0 }} },
3697 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1,
false, 5, 0 }} },
3698 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2,
false, 3, 0 }} },
3699 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2,
false, 3, 0 }} },
3700 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2,
false, 5, 0 }} },
3701 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2,
false, 5, 0 }} },
3702 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2,
false, 5, 0 }} },
3703 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2,
false, 5, 0 }} },
3704 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1,
true , 6, 0 }} },
3705 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1,
true, 6, 0 }} },
3706 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1,
false, 5, 0 },
3707 { 2,
false, 5, 0 }} },
3708 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1,
false, 6, 0 },
3709 { 2,
false, 6, 0 }} },
3710 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0,
true, 6, 0 }} },
3711 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1,
false, 5, 0 }} },
3712 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2,
false, 5, 0 }} },
3713 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2,
false, 5, 0 }} },
3714 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2,
false, 5, 0 }} },
3715 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2,
false, 5, 0 }} },
3716 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3,
false, 2, 0 }} },
3717 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2,
false, 2, 0 }} },
3718 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
3719 {{ 1,
false, 4, 0 }} },
3720 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1,
false, 4, 0 }} },
3721 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
3722 {{ 1,
false, 4, 0 }} },
3723 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1,
false, 6, 0 }} },
3724 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2,
false, 6, 0 }} },
3725 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2,
false, 6, 0 }} },
3726 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2,
false, 6, 0 }} },
3727 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2,
false, 6, 0 }} },
3728 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2,
false, 6, 0 }} },
3729 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1,
false, 5, 0 }} },
3730 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2,
false, 5, 0 }} },
3731 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2,
false, 5, 0 }} },
3732 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2,
false, 5, 0 }} },
3733 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2,
false, 5, 0 }} },
3734 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2,
false, 5, 0 }} },
3735 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2,
false, 3, 0 }} },
3736 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2,
false, 3, 0 }} },
3737 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2,
false, 3, 0 }} },
3738 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2,
false, 3, 0 }} },
3739 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2,
false, 1, 0 }} },
3740 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2,
false, 1, 0 }} },
3741 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3,
false, 1, 0 }} },
3742 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
3743 {{ 3,
false, 1, 0 }} },
3744 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2,
false, 1, 0 }} },
3745 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2,
false, 1, 0 }} },
3746 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3,
false, 1, 0 }} },
3747 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
3748 {{ 3,
false, 1, 0 }} },
3749 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2,
false, 1, 0 }} },
3750 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2,
false, 1, 0 }} },
3751 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3,
false, 1, 0 }} },
3752 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
3753 {{ 3,
false, 1, 0 }} },
3755 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2,
false, 2, 0 }} },
3756 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
3757 {{ 2,
false, 2, 0 }} },
3758 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
3759 {{ 3,
false, 2, 0 }} },
3760 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
3761 {{ 3,
false, 2, 0 }} },
3762 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2,
false, 2, 0 }} },
3763 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
3764 {{ 2,
false, 2, 0 }} },
3765 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
3766 {{ 3,
false, 2, 0 }} },
3767 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
3768 {{ 3,
false, 2, 0 }} },
3769 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2,
false, 3, 0 }} },
3770 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2,
false, 3, 0 }} },
3771 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3,
false, 3, 0 }} },
3772 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
3773 {{ 3,
false, 3, 0 }} },
3774 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2,
false, 3, 0 }} },
3775 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2,
false, 3, 0 }} },
3776 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3,
false, 3, 0 }} },
3777 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
3778 {{ 3,
false, 3, 0 }} },
3783 static const bool SortOnce =
3786 return LHS.BuiltinID < RHS.BuiltinID;
3792 Infos, [=](
const BuiltinInfo &BI) {
return BI.BuiltinID < BuiltinID; });
3793 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
3798 for (
const ArgInfo &A : F->Infos) {
3800 if (A.BitWidth == 0)
3803 int32_t Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
3804 int32_t Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
3806 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
3808 unsigned M = 1 << A.Align;
3811 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
3812 Error |= SemaBuiltinConstantArgMultiple(TheCall, A.OpNum, M);
3818bool Sema::CheckHexagonBuiltinFunctionCall(
unsigned BuiltinID,
3820 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
3823bool Sema::CheckLoongArchBuiltinFunctionCall(
const TargetInfo &TI,
3826 switch (BuiltinID) {
3829 case LoongArch::BI__builtin_loongarch_cacop_d:
3832 diag::err_loongarch_builtin_requires_la64)
3835 case LoongArch::BI__builtin_loongarch_cacop_w: {
3836 if (BuiltinID == LoongArch::BI__builtin_loongarch_cacop_w &&
3839 diag::err_loongarch_builtin_requires_la32)
3841 SemaBuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
3842 SemaBuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12),
3846 case LoongArch::BI__builtin_loongarch_crc_w_b_w:
3847 case LoongArch::BI__builtin_loongarch_crc_w_h_w:
3848 case LoongArch::BI__builtin_loongarch_crc_w_w_w:
3849 case LoongArch::BI__builtin_loongarch_crc_w_d_w:
3850 case LoongArch::BI__builtin_loongarch_crcc_w_b_w:
3851 case LoongArch::BI__builtin_loongarch_crcc_w_h_w:
3852 case LoongArch::BI__builtin_loongarch_crcc_w_w_w:
3853 case LoongArch::BI__builtin_loongarch_crcc_w_d_w:
3854 case LoongArch::BI__builtin_loongarch_iocsrrd_d:
3855 case LoongArch::BI__builtin_loongarch_iocsrwr_d:
3856 case LoongArch::BI__builtin_loongarch_asrtle_d:
3857 case LoongArch::BI__builtin_loongarch_asrtgt_d:
3860 diag::err_loongarch_builtin_requires_la64)
3863 case LoongArch::BI__builtin_loongarch_break:
3864 case LoongArch::BI__builtin_loongarch_dbar:
3865 case LoongArch::BI__builtin_loongarch_ibar:
3866 case LoongArch::BI__builtin_loongarch_syscall:
3868 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 32767);
3869 case LoongArch::BI__builtin_loongarch_csrrd_w:
3870 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 16383);
3871 case LoongArch::BI__builtin_loongarch_csrwr_w:
3872 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 16383);
3873 case LoongArch::BI__builtin_loongarch_csrxchg_w:
3874 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 16383);
3875 case LoongArch::BI__builtin_loongarch_csrrd_d:
3878 diag::err_loongarch_builtin_requires_la64)
3880 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 16383);
3881 case LoongArch::BI__builtin_loongarch_csrwr_d:
3884 diag::err_loongarch_builtin_requires_la64)
3886 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 16383);
3887 case LoongArch::BI__builtin_loongarch_csrxchg_d:
3890 diag::err_loongarch_builtin_requires_la64)
3892 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 16383);
3893 case LoongArch::BI__builtin_loongarch_lddir_d:
3894 case LoongArch::BI__builtin_loongarch_ldpte_d:
3897 diag::err_loongarch_builtin_requires_la64)
3899 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
3900 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
3901 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
3902 return SemaBuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
3908bool Sema::CheckMipsBuiltinFunctionCall(
const TargetInfo &TI,
3909 unsigned BuiltinID,
CallExpr *TheCall) {
3910 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
3911 CheckMipsBuiltinArgument(BuiltinID, TheCall);
3914bool Sema::CheckMipsBuiltinCpu(
const TargetInfo &TI,
unsigned BuiltinID,
3917 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
3918 BuiltinID <= Mips::BI__builtin_mips_lwx) {
3920 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_dsp);
3923 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
3924 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
3927 diag::err_mips_builtin_requires_dspr2);
3930 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
3931 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
3933 return Diag(TheCall->
getBeginLoc(), diag::err_mips_builtin_requires_msa);
3948bool Sema::CheckMipsBuiltinArgument(
unsigned BuiltinID,
CallExpr *TheCall) {
3949 unsigned i = 0, l = 0, u = 0, m = 0;
3950 switch (BuiltinID) {
3951 default:
return false;
3952 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63;
break;
3953 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63;
break;
3954 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31;
break;
3955 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3;
break;
3956 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31;
break;
3957 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31;
break;
3958 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31;
break;
3962 case Mips::BI__builtin_msa_bclri_b:
3963 case Mips::BI__builtin_msa_bnegi_b:
3964 case Mips::BI__builtin_msa_bseti_b:
3965 case Mips::BI__builtin_msa_sat_s_b:
3966 case Mips::BI__builtin_msa_sat_u_b:
3967 case Mips::BI__builtin_msa_slli_b:
3968 case Mips::BI__builtin_msa_srai_b:
3969 case Mips::BI__builtin_msa_srari_b:
3970 case Mips::BI__builtin_msa_srli_b:
3971 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7;
break;
3972 case Mips::BI__builtin_msa_binsli_b:
3973 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7;
break;
3975 case Mips::BI__builtin_msa_bclri_h:
3976 case Mips::BI__builtin_msa_bnegi_h:
3977 case Mips::BI__builtin_msa_bseti_h:
3978 case Mips::BI__builtin_msa_sat_s_h:
3979 case Mips::BI__builtin_msa_sat_u_h:
3980 case Mips::BI__builtin_msa_slli_h:
3981 case Mips::BI__builtin_msa_srai_h:
3982 case Mips::BI__builtin_msa_srari_h:
3983 case Mips::BI__builtin_msa_srli_h:
3984 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15;
break;
3985 case Mips::BI__builtin_msa_binsli_h:
3986 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15;
break;
3990 case Mips::BI__builtin_msa_cfcmsa:
3991 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31;
break;
3992 case Mips::BI__builtin_msa_clei_u_b:
3993 case Mips::BI__builtin_msa_clei_u_h:
3994 case Mips::BI__builtin_msa_clei_u_w:
3995 case Mips::BI__builtin_msa_clei_u_d:
3996 case Mips::BI__builtin_msa_clti_u_b:
3997 case Mips::BI__builtin_msa_clti_u_h:
3998 case Mips::BI__builtin_msa_clti_u_w:
3999 case Mips::BI__builtin_msa_clti_u_d:
4000 case Mips::BI__builtin_msa_maxi_u_b:
4001 case Mips::BI__builtin_msa_maxi_u_h:
4002 case Mips::BI__builtin_msa_maxi_u_w:
4003 case Mips::BI__builtin_msa_maxi_u_d:
4004 case Mips::BI__builtin_msa_mini_u_b:
4005 case Mips::BI__builtin_msa_mini_u_h:
4006 case Mips::BI__builtin_msa_mini_u_w:
4007 case Mips::BI__builtin_msa_mini_u_d:
4008 case Mips::BI__builtin_msa_addvi_b:
4009 case Mips::BI__builtin_msa_addvi_h:
4010 case Mips::BI__builtin_msa_addvi_w:
4011 case Mips::BI__builtin_msa_addvi_d:
4012 case Mips::BI__builtin_msa_bclri_w:
4013 case Mips::BI__builtin_msa_bnegi_w:
4014 case Mips::BI__builtin_msa_bseti_w:
4015 case Mips::BI__builtin_msa_sat_s_w:
4016 case Mips::BI__builtin_msa_sat_u_w:
4017 case Mips::BI__builtin_msa_slli_w:
4018 case Mips::BI__builtin_msa_srai_w:
4019 case Mips::BI__builtin_msa_srari_w:
4020 case Mips::BI__builtin_msa_srli_w:
4021 case Mips::BI__builtin_msa_srlri_w:
4022 case Mips::BI__builtin_msa_subvi_b:
4023 case Mips::BI__builtin_msa_subvi_h:
4024 case Mips::BI__builtin_msa_subvi_w:
4025 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31;
break;
4026 case Mips::BI__builtin_msa_binsli_w:
4027 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31;
break;
4029 case Mips::BI__builtin_msa_bclri_d:
4030 case Mips::BI__builtin_msa_bnegi_d:
4031 case Mips::BI__builtin_msa_bseti_d:
4032 case Mips::BI__builtin_msa_sat_s_d:
4033 case Mips::BI__builtin_msa_sat_u_d:
4034 case Mips::BI__builtin_msa_slli_d:
4035 case Mips::BI__builtin_msa_srai_d:
4036 case Mips::BI__builtin_msa_srari_d:
4037 case Mips::BI__builtin_msa_srli_d:
4038 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63;
break;
4039 case Mips::BI__builtin_msa_binsli_d:
4040 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63;
break;
4042 case Mips::BI__builtin_msa_ceqi_b:
4043 case Mips::BI__builtin_msa_ceqi_h:
4044 case Mips::BI__builtin_msa_ceqi_w:
4045 case Mips::BI__builtin_msa_ceqi_d:
4046 case Mips::BI__builtin_msa_clti_s_b:
4047 case Mips::BI__builtin_msa_clti_s_h:
4048 case Mips::BI__builtin_msa_clti_s_w:
4049 case Mips::BI__builtin_msa_clti_s_d:
4050 case Mips::BI__builtin_msa_clei_s_b:
4051 case Mips::BI__builtin_msa_clei_s_h:
4052 case Mips::BI__builtin_msa_clei_s_w:
4053 case Mips::BI__builtin_msa_clei_s_d:
4054 case Mips::BI__builtin_msa_maxi_s_b:
4055 case Mips::BI__builtin_msa_maxi_s_h:
4056 case Mips::BI__builtin_msa_maxi_s_w:
4057 case Mips::BI__builtin_msa_maxi_s_d:
4058 case Mips::BI__builtin_msa_mini_s_b:
4059 case Mips::BI__builtin_msa_mini_s_h:
4060 case Mips::BI__builtin_msa_mini_s_w:
4061 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15;
break;
4063 case Mips::BI__builtin_msa_andi_b:
4064 case Mips::BI__builtin_msa_nori_b:
4065 case Mips::BI__builtin_msa_ori_b:
4066 case Mips::BI__builtin_msa_shf_b:
4067 case Mips::BI__builtin_msa_shf_h:
4068 case Mips::BI__builtin_msa_shf_w:
4069 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255;
break;
4070 case Mips::BI__builtin_msa_bseli_b:
4071 case Mips::BI__builtin_msa_bmnzi_b:
4072 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255;
break;
4075 case Mips::BI__builtin_msa_copy_s_b:
4076 case Mips::BI__builtin_msa_copy_u_b:
4077 case Mips::BI__builtin_msa_insve_b:
4078 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15;
break;
4079 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15;
break;
4081 case Mips::BI__builtin_msa_copy_s_h:
4082 case Mips::BI__builtin_msa_copy_u_h:
4083 case Mips::BI__builtin_msa_insve_h:
4084 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7;
break;
4085 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7;
break;
4087 case Mips::BI__builtin_msa_copy_s_w:
4088 case Mips::BI__builtin_msa_copy_u_w:
4089 case Mips::BI__builtin_msa_insve_w:
4090 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3;
break;
4091 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3;
break;
4093 case Mips::BI__builtin_msa_copy_s_d:
4094 case Mips::BI__builtin_msa_copy_u_d:
4095 case Mips::BI__builtin_msa_insve_d:
4096 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1;
break;
4097 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1;
break;
4100 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255;
break;
4101 case Mips::BI__builtin_msa_ldi_h:
4102 case Mips::BI__builtin_msa_ldi_w:
4103 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511;
break;
4104 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1;
break;
4105 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2;
break;
4106 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4;
break;
4107 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8;
break;
4108 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8;
break;
4109 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4;
break;
4110 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1;
break;
4111 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2;
break;
4112 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4;
break;
4113 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8;
break;
4114 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8;
break;
4115 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4;
break;
4119 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
4121 return SemaBuiltinConstantArgRange(TheCall, i, l, u) ||
4122 SemaBuiltinConstantArgMultiple(TheCall, i, m);
4133 bool RequireICE =
false;
4141 unsigned size = strtoul(Str, &End, 10);
4142 assert(End != Str &&
"Missing constant parameter constraint");
4145 return Context.
IntTy;
4149 unsigned size = strtoul(Str, &End, 10);
4150 assert(End != Str &&
"Missing PowerPC MMA type size");
4154 #define PPC_VECTOR_TYPE(typeName, Id, size) \
4155 case size: Type = Context.Id##Ty; break;
4156 #include "clang/Basic/PPCTypes.def"
4157 default: llvm_unreachable(
"Invalid PowerPC MMA vector type");
4159 bool CheckVectorArgs =
false;
4160 while (!CheckVectorArgs) {
4169 CheckVectorArgs =
true;
4183 switch (BuiltinID) {
4184 case PPC::BI__builtin_divde:
4185 case PPC::BI__builtin_divdeu:
4186 case PPC::BI__builtin_bpermd:
4187 case PPC::BI__builtin_pdepd:
4188 case PPC::BI__builtin_pextd:
4189 case PPC::BI__builtin_ppc_ldarx:
4190 case PPC::BI__builtin_ppc_stdcx:
4191 case PPC::BI__builtin_ppc_tdw:
4192 case PPC::BI__builtin_ppc_trapd:
4193 case PPC::BI__builtin_ppc_cmpeqb:
4194 case PPC::BI__builtin_ppc_setb:
4195 case PPC::BI__builtin_ppc_mulhd:
4196 case PPC::BI__builtin_ppc_mulhdu:
4197 case PPC::BI__builtin_ppc_maddhd:
4198 case PPC::BI__builtin_ppc_maddhdu:
4199 case PPC::BI__builtin_ppc_maddld:
4200 case PPC::BI__builtin_ppc_load8r:
4201 case PPC::BI__builtin_ppc_store8r:
4202 case PPC::BI__builtin_ppc_insert_exp:
4203 case PPC::BI__builtin_ppc_extract_sig:
4204 case PPC::BI__builtin_ppc_addex:
4205 case PPC::BI__builtin_darn:
4206 case PPC::BI__builtin_darn_raw:
4207 case PPC::BI__builtin_ppc_compare_and_swaplp:
4208 case PPC::BI__builtin_ppc_fetch_and_addlp:
4209 case PPC::BI__builtin_ppc_fetch_and_andlp:
4210 case PPC::BI__builtin_ppc_fetch_and_orlp:
4211 case PPC::BI__builtin_ppc_fetch_and_swaplp:
4221bool Sema::SemaValueIsRunOfOnes(
CallExpr *TheCall,
unsigned ArgNum) {
4229 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
4233 if (
Result.isShiftedMask() || (~
Result).isShiftedMask())
4237 diag::err_argument_not_contiguous_bit_field)
4241bool Sema::CheckPPCBuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
4243 unsigned i = 0, l = 0, u = 0;
4248 return Diag(TheCall->
getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
4251 switch (BuiltinID) {
4252 default:
return false;
4253 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
4254 case PPC::BI__builtin_altivec_crypto_vshasigmad:
4255 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
4256 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
4257 case PPC::BI__builtin_altivec_dss:
4258 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
4259 case PPC::BI__builtin_tbegin:
4260 case PPC::BI__builtin_tend:
4261 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
4262 case PPC::BI__builtin_tsr:
4263 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7);
4264 case PPC::BI__builtin_tabortwc:
4265 case PPC::BI__builtin_tabortdc:
4266 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
4267 case PPC::BI__builtin_tabortwci:
4268 case PPC::BI__builtin_tabortdci:
4269 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
4270 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4274 case PPC::BI__builtin_unpack_longdouble:
4275 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 1))
4278 case PPC::BI__builtin_pack_longdouble:
4280 return Diag(TheCall->
getBeginLoc(), diag::err_ppc_builtin_requires_abi)
4283 case PPC::BI__builtin_altivec_dst:
4284 case PPC::BI__builtin_altivec_dstt:
4285 case PPC::BI__builtin_altivec_dstst:
4286 case PPC::BI__builtin_altivec_dststt:
4287 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4288 case PPC::BI__builtin_vsx_xxpermdi:
4289 case PPC::BI__builtin_vsx_xxsldwi:
4290 return SemaBuiltinVSX(TheCall);
4291 case PPC::BI__builtin_unpack_vector_int128:
4292 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
4293 case PPC::BI__builtin_altivec_vgnb:
4294 return SemaBuiltinConstantArgRange(TheCall, 1, 2, 7);
4295 case PPC::BI__builtin_vsx_xxeval:
4296 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 255);
4297 case PPC::BI__builtin_altivec_vsldbi:
4298 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
4299 case PPC::BI__builtin_altivec_vsrdbi:
4300 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
4301 case PPC::BI__builtin_vsx_xxpermx:
4302 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
4303 case PPC::BI__builtin_ppc_tw:
4304 case PPC::BI__builtin_ppc_tdw:
4305 return SemaBuiltinConstantArgRange(TheCall, 2, 1, 31);
4306 case PPC::BI__builtin_ppc_cmprb:
4307 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
4310 case PPC::BI__builtin_ppc_rlwnm:
4311 return SemaValueIsRunOfOnes(TheCall, 2);
4312 case PPC::BI__builtin_ppc_rlwimi:
4313 case PPC::BI__builtin_ppc_rldimi:
4314 return SemaBuiltinConstantArg(TheCall, 2,
Result) ||
4315 SemaValueIsRunOfOnes(TheCall, 3);
4316 case PPC::BI__builtin_ppc_addex: {
4317 if (SemaBuiltinConstantArgRange(TheCall, 2, 0, 3))
4327 case PPC::BI__builtin_ppc_mtfsb0:
4328 case PPC::BI__builtin_ppc_mtfsb1:
4329 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
4330 case PPC::BI__builtin_ppc_mtfsf:
4331 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 255);
4332 case PPC::BI__builtin_ppc_mtfsfi:
4333 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7) ||
4334 SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
4335 case PPC::BI__builtin_ppc_alignx:
4336 return SemaBuiltinConstantArgPower2(TheCall, 0);
4337 case PPC::BI__builtin_ppc_rdlam:
4338 return SemaValueIsRunOfOnes(TheCall, 2);
4339 case PPC::BI__builtin_vsx_ldrmb:
4340 case PPC::BI__builtin_vsx_strmb:
4341 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
4342 case PPC::BI__builtin_altivec_vcntmbb:
4343 case PPC::BI__builtin_altivec_vcntmbh:
4344 case PPC::BI__builtin_altivec_vcntmbw:
4345 case PPC::BI__builtin_altivec_vcntmbd:
4346 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
4347 case PPC::BI__builtin_vsx_xxgenpcvbm:
4348 case PPC::BI__builtin_vsx_xxgenpcvhm:
4349 case PPC::BI__builtin_vsx_xxgenpcvwm:
4350 case PPC::BI__builtin_vsx_xxgenpcvdm:
4351 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
4352 case PPC::BI__builtin_ppc_test_data_class: {
4360 diag::err_ppc_invalid_test_data_class_type);
4361 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 127);
4363 case PPC::BI__builtin_ppc_maxfe:
4364 case PPC::BI__builtin_ppc_minfe:
4365 case PPC::BI__builtin_ppc_maxfl:
4366 case PPC::BI__builtin_ppc_minfl:
4367 case PPC::BI__builtin_ppc_maxfs:
4368 case PPC::BI__builtin_ppc_minfs: {
4370 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
4371 BuiltinID == PPC::BI__builtin_ppc_minfe))
4372 return Diag(TheCall->
getBeginLoc(), diag::err_target_unsupported_type)
4377 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
4378 BuiltinID == PPC::BI__builtin_ppc_minfl)
4380 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
4381 BuiltinID == PPC::BI__builtin_ppc_minfs)
4383 for (
unsigned I = 0, E = TheCall->
getNumArgs(); I < E; ++I)
4386 diag::err_typecheck_convert_incompatible)
4390#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
4391 case PPC::BI__builtin_##Name: \
4392 return SemaBuiltinPPCMMACall(TheCall, BuiltinID, Types);
4393#include "clang/Basic/BuiltinsPPC.def"
4395 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
4404 QualType CoreType =
Type.getCanonicalType().getUnqualifiedType();
4405#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
4407#include
"clang/Basic/PPCTypes.def"
4409 Diag(
TypeLoc, diag::err_ppc_invalid_use_mma_type);
4415bool Sema::CheckAMDGCNBuiltinFunctionCall(
unsigned BuiltinID,
4418 unsigned OrderIndex, ScopeIndex;
4419 switch (BuiltinID) {
4420 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
4421 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
4422 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
4423 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
4427 case AMDGPU::BI__builtin_amdgcn_fence:
4436 auto ArgExpr = Arg.
get();
4439 if (!ArgExpr->EvaluateAsInt(ArgResult,
Context))
4440 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
4441 << ArgExpr->getType();
4442 auto Ord = ArgResult.
Val.
getInt().getZExtValue();
4446 if (!llvm::isValidAtomicOrderingCABI(Ord))
4447 return Diag(ArgExpr->getBeginLoc(),
4448 diag::warn_atomic_op_has_invalid_memory_order)
4449 << ArgExpr->getSourceRange();
4450 switch (
static_cast<llvm::AtomicOrderingCABI
>(Ord)) {
4451 case llvm::AtomicOrderingCABI::relaxed:
4452 case llvm::AtomicOrderingCABI::consume:
4453 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
4454 return Diag(ArgExpr->getBeginLoc(),
4455 diag::warn_atomic_op_has_invalid_memory_order)
4456 << ArgExpr->getSourceRange();
4458 case llvm::AtomicOrderingCABI::acquire:
4459 case llvm::AtomicOrderingCABI::release:
4460 case llvm::AtomicOrderingCABI::acq_rel:
4461 case llvm::AtomicOrderingCABI::seq_cst:
4465 Arg = TheCall->
getArg(ScopeIndex);
4466 ArgExpr = Arg.
get();
4469 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1,
Context))
4470 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
4471 << ArgExpr->getType();
4476bool Sema::CheckRISCVLMUL(
CallExpr *TheCall,
unsigned ArgNum) {
4485 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
4488 int64_t Val =
Result.getSExtValue();
4489 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
4492 return Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
4496bool Sema::CheckRISCVBuiltinFunctionCall(
const TargetInfo &TI,
4501 bool FeatureMissing =
false;
4504 Features.split(ReqFeatures,
',', -1,
false);
4507 for (StringRef F : ReqFeatures) {
4509 F.split(ReqOpFeatures,
'|');
4511 if (llvm::none_of(ReqOpFeatures,
4512 [&TI](StringRef OF) {
return TI.
hasFeature(OF); })) {
4513 std::string FeatureStrs;
4514 bool IsExtension =
true;
4515 for (StringRef OF : ReqOpFeatures) {
4518 if (OF ==
"64bit") {
4519 assert(ReqOpFeatures.size() == 1 &&
"Expected '64bit' to be alone");
4521 IsExtension =
false;
4523 if (OF ==
"32bit") {
4524 assert(ReqOpFeatures.size() == 1 &&
"Expected '32bit' to be alone");
4526 IsExtension =
false;
4530 OF.consume_front(
"experimental-");
4531 std::string FeatureStr = OF.str();
4532 FeatureStr[0] = std::toupper(FeatureStr[0]);
4534 FeatureStrs += FeatureStrs.empty() ?
"" :
", ";
4536 FeatureStrs += FeatureStr;
4540 FeatureMissing =
true;
4541 Diag(TheCall->
getBeginLoc(), diag::err_riscv_builtin_requires_extension)
4552 switch (BuiltinID) {
4555 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
4556 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
4557 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
4558 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
4559 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
4560 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
4561 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
4562 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
4563 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
4564 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
4565 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
4566 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
4567 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
4568 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
4569 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
4570 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
4571 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
4572 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
4573 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
4574 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
4575 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
4576 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
4577 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
4578 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
4579 case RISCVVector::BI__builtin_rvv_vmulh_vv:
4580 case RISCVVector::BI__builtin_rvv_vmulh_vx:
4581 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
4582 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
4583 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
4584 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
4585 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
4586 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
4587 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
4588 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
4589 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
4590 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
4591 case RISCVVector::BI__builtin_rvv_vsmul_vv:
4592 case RISCVVector::BI__builtin_rvv_vsmul_vx:
4593 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
4594 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
4595 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
4596 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
4597 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
4598 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
4599 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
4600 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
4601 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
4602 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
4603 bool RequireV =
false;
4604 for (
unsigned ArgNum = 0; ArgNum < TheCall->
getNumArgs(); ++ArgNum)
4610 diag::err_riscv_builtin_requires_extension)
4617 switch (BuiltinID) {
4618 case RISCVVector::BI__builtin_rvv_vsetvli:
4619 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3) ||
4620 CheckRISCVLMUL(TheCall, 2);
4621 case RISCVVector::BI__builtin_rvv_vsetvlimax:
4622 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4623 CheckRISCVLMUL(TheCall, 1);
4624 case RISCVVector::BI__builtin_rvv_vget_v: {
4635 MaxIndex = (VecInfo.
EC.getKnownMinValue() * VecInfo.
NumVectors) /
4636 (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors);
4637 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
4639 case RISCVVector::BI__builtin_rvv_vset_v: {
4650 MaxIndex = (ResVecInfo.
EC.getKnownMinValue() * ResVecInfo.
NumVectors) /
4652 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
4654 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf8:
4655 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf4:
4656 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf2:
4657 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m1:
4658 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m2:
4659 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m4:
4660 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m8:
4661 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16mf4:
4662 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16mf2:
4663 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m1:
4664 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m2:
4665 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m4:
4666 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m8:
4667 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32mf2:
4668 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m1:
4669 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m2:
4670 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m4:
4671 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m8:
4672 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m1:
4673 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m2:
4674 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m4:
4675 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m8:
4677 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4678 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4679 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31) ||
4680 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
4681 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
4683 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4684 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4685 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
4686 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
4687 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
4689 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4690 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4691 SemaBuiltinConstantArgRange(TheCall, 2, -16, 15);
4692 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
4693 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
4695 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4696 SemaBuiltinConstantArgRange(TheCall, 2, -16, 15);
4697 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
4698 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
4699 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
4700 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
4701 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
4702 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
4704 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4705 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
4706 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8mf8:
4707 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8mf4:
4708 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8mf2:
4709 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m1:
4710 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m2:
4711 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m4:
4712 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m8:
4713 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16mf4:
4714 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16mf2:
4715 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m1:
4716 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m2:
4717 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m4:
4718 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m8:
4719 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32mf2:
4720 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m1:
4721 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m2:
4722 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m4:
4723 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m8:
4724 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m1:
4725 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m2:
4726 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m4:
4727 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m8:
4729 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4730 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4731 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4732 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
4733 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
4735 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
4736 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
4738 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4739 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4740 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
4741 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
4742 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
4743 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
4745 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
4746 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
4747 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
4748 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
4750 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
4751 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
4752 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
4753 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
4754 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
4755 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
4756 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
4757 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
4759 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
4760 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
4762 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1) ||
4763 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4764 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
4765 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
4766 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
4767 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
4768 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
4769 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
4771 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
4772 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
4774 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
4776 case RISCV::BI__builtin_riscv_aes32dsi:
4777 case RISCV::BI__builtin_riscv_aes32dsmi:
4778 case RISCV::BI__builtin_riscv_aes32esi:
4779 case RISCV::BI__builtin_riscv_aes32esmi:
4780 case RISCV::BI__builtin_riscv_sm4ks:
4781 case RISCV::BI__builtin_riscv_sm4ed:
4782 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4784 case RISCV::BI__builtin_riscv_aes64ks1i:
4785 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 10);
4787 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
4788 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
4789 case RISCVVector::BI__builtin_rvv_vaadd_vv:
4790 case RISCVVector::BI__builtin_rvv_vaadd_vx:
4791 case RISCVVector::BI__builtin_rvv_vasubu_vv:
4792 case RISCVVector::BI__builtin_rvv_vasubu_vx:
4793 case RISCVVector::BI__builtin_rvv_vasub_vv:
4794 case RISCVVector::BI__builtin_rvv_vasub_vx:
4795 case RISCVVector::BI__builtin_rvv_vsmul_vv:
4796 case RISCVVector::BI__builtin_rvv_vsmul_vx:
4797 case RISCVVector::BI__builtin_rvv_vssra_vv:
4798 case RISCVVector::BI__builtin_rvv_vssra_vx:
4799 case RISCVVector::BI__builtin_rvv_vssrl_vv:
4800 case RISCVVector::BI__builtin_rvv_vssrl_vx:
4801 case RISCVVector::BI__builtin_rvv_vnclip_wv:
4802 case RISCVVector::BI__builtin_rvv_vnclip_wx:
4803 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
4804 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
4805 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4806 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
4807 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
4808 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
4809 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
4810 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
4811 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
4812 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
4813 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
4814 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
4815 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
4816 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
4817 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
4818 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
4819 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
4820 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
4821 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
4822 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
4823 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
4824 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
4825 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
4826 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
4827 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
4828 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
4829 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
4830 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
4831 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
4832 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
4833 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
4834 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
4835 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
4836 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
4837 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
4838 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
4839 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
4840 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
4841 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
4842 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 3);
4843 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
4844 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
4845 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
4846 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
4847 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
4848 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
4849 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
4850 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
4851 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
4852 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
4853 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
4854 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
4855 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
4856 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
4857 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
4858 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
4859 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
4860 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
4861 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
4862 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
4863 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
4864 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
4865 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
4866 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
4867 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
4868 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
4869 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
4870 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
4871 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
4872 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
4873 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
4874 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
4875 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
4876 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
4877 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
4878 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
4879 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
4880 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
4881 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
4882 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
4883 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
4884 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
4885 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
4886 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
4887 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
4888 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
4889 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
4890 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
4891 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
4892 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
4893 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
4894 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
4895 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
4896 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
4897 return SemaBuiltinConstantArgRange(TheCall, 4, 0, 3);
4898 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
4899 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
4900 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
4901 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
4902 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
4903 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
4904 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
4905 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
4906 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
4907 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
4908 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
4909 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
4910 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
4911 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 4);
4912 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
4913 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
4914 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
4915 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
4916 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
4917 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
4918 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
4919 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
4920 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
4921 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
4922 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
4923 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
4924 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
4925 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
4926 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
4927 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
4928 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
4929 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
4930 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
4931 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
4932 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
4933 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
4934 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
4935 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
4936 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
4937 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
4938 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
4939 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
4940 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
4941 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
4942 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
4943 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
4944 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
4945 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
4946 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
4947 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
4948 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
4949 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
4950 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
4951 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
4952 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
4953 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
4954 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
4955 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
4956 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
4957 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
4958 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
4959 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
4960 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
4961 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
4962 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 4);
4963 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
4964 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
4965 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
4966 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
4967 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
4968 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
4969 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
4970 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
4971 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
4972 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
4973 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
4974 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
4975 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
4976 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
4977 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
4978 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
4979 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
4980 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
4981 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
4982 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
4983 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
4984 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
4985 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
4986 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
4987 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
4988 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
4989 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
4990 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
4991 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
4992 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
4993 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
4994 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
4995 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
4996 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
4997 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
4998 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
4999 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
5000 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
5001 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
5002 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
5003 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
5004 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
5005 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
5006 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
5007 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
5008 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
5009 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
5010 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
5011 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
5012 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
5013 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
5014 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
5015 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
5016 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
5017 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
5018 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
5019 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
5020 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
5021 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
5022 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
5023 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
5024 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
5025 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
5026 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
5027 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
5028 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
5029 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
5030 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
5031 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
5032 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
5033 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
5034 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
5035 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
5036 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
5037 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
5038 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
5039 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
5040 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
5041 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
5042 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
5043 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
5044 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
5045 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
5046 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
5047 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
5048 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
5049 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
5050 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
5051 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
5052 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
5053 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
5054 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
5055 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
5056 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
5057 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
5058 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
5059 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
5060 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
5061 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
5062 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
5063 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
5064 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
5065 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
5066 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
5067 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
5068 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
5069 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
5070 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
5071 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
5072 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
5073 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
5074 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
5075 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
5076 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
5077 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
5078 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
5079 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
5080 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
5081 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
5082 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
5083 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
5084 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
5085 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
5086 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
5087 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
5088 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
5089 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
5090 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
5091 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
5092 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
5093 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
5094 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
5095 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
5096 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
5097 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
5098 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 4);
5099 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
5100 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
5101 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
5102 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
5103 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
5104 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
5105 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
5106 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
5107 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
5108 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
5109 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
5110 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
5111 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
5112 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
5113 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
5114 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
5115 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
5116 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
5117 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
5118 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
5119 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
5120 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
5121 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
5122 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
5123 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
5124 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
5125 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
5126 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
5127 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
5128 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
5129 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
5130 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
5131 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
5132 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
5133 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
5134 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
5135 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
5136 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
5137 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
5138 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
5139 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
5140 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
5141 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
5142 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
5143 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
5144 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
5145 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
5146 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
5147 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
5148 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
5149 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
5150 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
5151 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
5152 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
5153 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
5154 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
5155 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
5156 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
5157 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
5158 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
5159 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
5160 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
5161 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
5162 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
5163 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
5164 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
5165 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
5166 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
5167 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
5168 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
5169 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
5170 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
5171 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
5172 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
5173 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
5174 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
5175 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
5176 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
5177 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
5178 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
5179 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
5180 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
5181 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
5182 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
5183 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
5184 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
5185 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
5186 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
5187 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
5188 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
5189 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
5190 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
5191 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
5192 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
5193 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
5194 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
5195 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
5196 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
5197 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
5198 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
5199 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
5200 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
5201 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
5202 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
5203 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
5204 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
5205 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
5206 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
5207 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
5208 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
5209 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
5210 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
5211 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
5212 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
5213 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
5214 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
5215 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
5216 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
5217 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
5218 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
5219 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
5220 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
5221 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
5222 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
5223 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
5224 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
5225 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
5226 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
5227 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
5228 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
5229 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
5230 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
5231 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
5232 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
5233 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
5234 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
5235 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
5236 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
5237 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
5238 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
5239 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
5240 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
5241 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
5242 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
5243 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
5244 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
5245 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
5246 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
5247 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
5248 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
5249 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
5250 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
5251 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
5252 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
5253 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
5254 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
5255 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
5256 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
5257 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
5258 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
5259 return SemaBuiltinConstantArgRange(TheCall, 4, 0, 4);
5260 case RISCV::BI__builtin_riscv_ntl_load:
5261 case RISCV::BI__builtin_riscv_ntl_store:
5264 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
5265 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
5266 "Unexpected RISC-V nontemporal load/store builtin!");
5267 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
5268 unsigned NumArgs = IsStore ? 3 : 2;
5275 if (SemaBuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
5284 PointerArg = PointerArgResult.
get();
5288 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
5299 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
5324bool Sema::CheckSystemZBuiltinFunctionCall(
unsigned BuiltinID,
5326 if (BuiltinID == SystemZ::BI__builtin_tabort) {
5328 if (std::optional<llvm::APSInt> AbortCode =
5330 if (AbortCode->getSExtValue() >= 0 && AbortCode->getSExtValue() < 256)
5331 return Diag(Arg->
getBeginLoc(), diag::err_systemz_invalid_tabort_code)
5337 unsigned i = 0, l = 0, u = 0;
5338 switch (BuiltinID) {
5339 default:
return false;
5340 case SystemZ::BI__builtin_s390_lcbb: i = 1; l = 0; u = 15;
break;
5341 case SystemZ::BI__builtin_s390_verimb:
5342 case SystemZ::BI__builtin_s390_verimh:
5343 case SystemZ::BI__builtin_s390_verimf:
5344 case SystemZ::BI__builtin_s390_verimg: i = 3; l = 0; u = 255;
break;
5345 case SystemZ::BI__builtin_s390_vfaeb:
5346 case SystemZ::BI__builtin_s390_vfaeh:
5347 case SystemZ::BI__builtin_s390_vfaef:
5348 case SystemZ::BI__builtin_s390_vfaebs:
5349 case SystemZ::BI__builtin_s390_vfaehs:
5350 case SystemZ::BI__builtin_s390_vfaefs:
5351 case SystemZ::BI__builtin_s390_vfaezb:
5352 case SystemZ::BI__builtin_s390_vfaezh:
5353 case SystemZ::BI__builtin_s390_vfaezf:
5354 case SystemZ::BI__builtin_s390_vfaezbs:
5355 case SystemZ::BI__builtin_s390_vfaezhs:
5356 case SystemZ::BI__builtin_s390_vfaezfs: i = 2; l = 0; u = 15;
break;
5357 case SystemZ::BI__builtin_s390_vfisb:
5358 case SystemZ::BI__builtin_s390_vfidb:
5359 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15) ||
5360 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
5361 case SystemZ::BI__builtin_s390_vftcisb:
5362 case SystemZ::BI__builtin_s390_vftcidb: i = 1; l = 0; u = 4095;
break;
5363 case SystemZ::BI__builtin_s390_vlbb: i = 1; l = 0; u = 15;
break;
5364 case SystemZ::BI__builtin_s390_vpdi: i = 2; l = 0; u = 15;
break;
5365 case SystemZ::BI__builtin_s390_vsldb: i = 2; l = 0; u = 15;
break;
5366 case SystemZ::BI__builtin_s390_vstrcb:
5367 case SystemZ::BI__builtin_s390_vstrch:
5368 case SystemZ::BI__builtin_s390_vstrcf:
5369 case SystemZ::BI__builtin_s390_vstrczb:
5370 case SystemZ::BI__builtin_s390_vstrczh:
5371 case SystemZ::BI__builtin_s390_vstrczf:
5372 case SystemZ::BI__builtin_s390_vstrcbs:
5373 case SystemZ::BI__builtin_s390_vstrchs:
5374 case SystemZ::BI__builtin_s390_vstrcfs:
5375 case SystemZ::BI__builtin_s390_vstrczbs:
5376 case SystemZ::BI__builtin_s390_vstrczhs:
5377 case SystemZ::BI__builtin_s390_vstrczfs: i = 3; l = 0; u = 15;
break;
5378 case SystemZ::BI__builtin_s390_vmslg: i = 3; l = 0; u = 15;
break;
5379 case SystemZ::BI__builtin_s390_vfminsb:
5380 case SystemZ::BI__builtin_s390_vfmaxsb:
5381 case SystemZ::BI__builtin_s390_vfmindb:
5382 case SystemZ::BI__builtin_s390_vfmaxdb: i = 2; l = 0; u = 15;
break;
5383 case SystemZ::BI__builtin_s390_vsld: i = 2; l = 0; u = 7;
break;
5384 case SystemZ::BI__builtin_s390_vsrd: i = 2; l = 0; u = 7;
break;
5385 case SystemZ::BI__builtin_s390_vclfnhs:
5386 case SystemZ::BI__builtin_s390_vclfnls:
5387 case SystemZ::BI__builtin_s390_vcfn:
5388 case SystemZ::BI__builtin_s390_vcnf: i = 1; l = 0; u = 15;
break;
5389 case SystemZ::BI__builtin_s390_vcrnfs: i = 2; l = 0; u = 15;
break;
5391 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
5394bool Sema::CheckWebAssemblyBuiltinFunctionCall(
const TargetInfo &TI,
5397 switch (BuiltinID) {
5398 case WebAssembly::BI__builtin_wasm_ref_null_extern:
5399 return BuiltinWasmRefNullExtern(TheCall);
5400 case WebAssembly::BI__builtin_wasm_ref_null_func:
5401 return BuiltinWasmRefNullFunc(TheCall);
5402 case WebAssembly::BI__builtin_wasm_table_get:
5403 return BuiltinWasmTableGet(TheCall);
5404 case WebAssembly::BI__builtin_wasm_table_set:
5405 return BuiltinWasmTableSet(TheCall);
5406 case WebAssembly::BI__builtin_wasm_table_size:
5407 return BuiltinWasmTableSize(TheCall);
5408 case WebAssembly::BI__builtin_wasm_table_grow:
5409 return BuiltinWasmTableGrow(TheCall);
5410 case WebAssembly::BI__builtin_wasm_table_fill:
5411 return BuiltinWasmTableFill(TheCall);
5412 case WebAssembly::BI__builtin_wasm_table_copy:
5413 return BuiltinWasmTableCopy(TheCall);
5426 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64x";
5429 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zvfh";
5432 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32f";
5435 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve64d";
5439 Diag(Loc, diag::err_riscv_type_requires_extension, D) << Ty <<
"zve32x";
5442bool Sema::CheckNVPTXBuiltinFunctionCall(
const TargetInfo &TI,
5445 switch (BuiltinID) {
5446 case NVPTX::BI__nvvm_cp_async_ca_shared_global_4:
5447 case NVPTX::BI__nvvm_cp_async_ca_shared_global_8:
5448 case NVPTX::BI__nvvm_cp_async_ca_shared_global_16:
5449 case NVPTX::BI__nvvm_cp_async_cg_shared_global_16:
5465 return S.
Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
5485 return S.
Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
5498bool Sema::CheckX86BuiltinRoundingOrSAE(
unsigned BuiltinID,
CallExpr *TheCall) {
5502 unsigned ArgNum = 0;
5503 switch (BuiltinID) {
5506 case X86::BI__builtin_ia32_vcvttsd2si32:
5507 case X86::BI__builtin_ia32_vcvttsd2si64:
5508 case X86::BI__builtin_ia32_vcvttsd2usi32:
5509 case X86::BI__builtin_ia32_vcvttsd2usi64:
5510 case X86::BI__builtin_ia32_vcvttss2si32:
5511 case X86::BI__builtin_ia32_vcvttss2si64:
5512 case X86::BI__builtin_ia32_vcvttss2usi32:
5513 case X86::BI__builtin_ia32_vcvttss2usi64:
5514 case X86::BI__builtin_ia32_vcvttsh2si32:
5515 case X86::BI__builtin_ia32_vcvttsh2si64:
5516 case X86::BI__builtin_ia32_vcvttsh2usi32:
5517 case X86::BI__builtin_ia32_vcvttsh2usi64:
5520 case X86::BI__builtin_ia32_maxpd512:
5521 case X86::BI__builtin_ia32_maxps512:
5522 case X86::BI__builtin_ia32_minpd512:
5523 case X86::BI__builtin_ia32_minps512:
5524 case X86::BI__builtin_ia32_maxph512:
5525 case X86::BI__builtin_ia32_minph512:
5528 case X86::BI__builtin_ia32_vcvtph2pd512_mask:
5529 case X86::BI__builtin_ia32_vcvtph2psx512_mask:
5530 case X86::BI__builtin_ia32_cvtps2pd512_mask:
5531 case X86::BI__builtin_ia32_cvttpd2dq512_mask:
5532 case X86::BI__builtin_ia32_cvttpd2qq512_mask:
5533 case X86::BI__builtin_ia32_cvttpd2udq512_mask:
5534 case X86::BI__builtin_ia32_cvttpd2uqq512_mask:
5535 case X86::BI__builtin_ia32_cvttps2dq512_mask:
5536 case X86::BI__builtin_ia32_cvttps2qq512_mask:
5537 case X86::BI__builtin_ia32_cvttps2udq512_mask:
5538 case X86::BI__builtin_ia32_cvttps2uqq512_mask:
5539 case X86::BI__builtin_ia32_vcvttph2w512_mask:
5540 case X86::BI__builtin_ia32_vcvttph2uw512_mask:
5541 case X86::BI__builtin_ia32_vcvttph2dq512_mask:
5542 case X86::BI__builtin_ia32_vcvttph2udq512_mask:
5543 case X86::BI__builtin_ia32_vcvttph2qq512_mask:
5544 case X86::BI__builtin_ia32_vcvttph2uqq512_mask:
5545 case X86::BI__builtin_ia32_exp2pd_mask:
5546 case X86::BI__builtin_ia32_exp2ps_mask:
5547 case X86::BI__builtin_ia32_getexppd512_mask:
5548 case X86::BI__builtin_ia32_getexpps512_mask:
5549 case X86::BI__builtin_ia32_getexpph512_mask:
5550 case X86::BI__builtin_ia32_rcp28pd_mask:
5551 case X86::BI__builtin_ia32_rcp28ps_mask:
5552 case X86::BI__builtin_ia32_rsqrt28pd_mask:
5553 case X86::BI__builtin_ia32_rsqrt28ps_mask:
5554 case X86::BI__builtin_ia32_vcomisd:
5555 case X86::BI__builtin_ia32_vcomiss:
5556 case X86::BI__builtin_ia32_vcomish:
5557 case X86::BI__builtin_ia32_vcvtph2ps512_mask:
5560 case X86::BI__builtin_ia32_cmppd512_mask:
5561 case X86::BI__builtin_ia32_cmpps512_mask:
5562 case X86::BI__builtin_ia32_cmpsd_mask:
5563 case X86::BI__builtin_ia32_cmpss_mask:
5564 case X86::BI__builtin_ia32_cmpsh_mask:
5565 case X86::BI__builtin_ia32_vcvtsh2sd_round_mask:
5566 case X86::BI__builtin_ia32_vcvtsh2ss_round_mask:
5567 case X86::BI__builtin_ia32_cvtss2sd_round_mask:
5568 case X86::BI__builtin_ia32_getexpsd128_round_mask:
5569 case X86::BI__builtin_ia32_getexpss128_round_mask:
5570 case X86::BI__builtin_ia32_getexpsh128_round_mask:
5571 case X86::BI__builtin_ia32_getmantpd512_mask:
5572 case X86::BI__builtin_ia32_getmantps512_mask:
5573 case X86::BI__builtin_ia32_getmantph512_mask:
5574 case X86::BI__builtin_ia32_maxsd_round_mask:
5575 case X86::BI__builtin_ia32_maxss_round_mask:
5576 case X86::BI__builtin_ia32_maxsh_round_mask:
5577 case X86::BI__builtin_ia32_minsd_round_mask:
5578 case X86::BI__builtin_ia32_minss_round_mask:
5579 case X86::BI__builtin_ia32_minsh_round_mask:
5580 case X86::BI__builtin_ia32_rcp28sd_round_mask:
5581 case X86::BI__builtin_ia32_rcp28ss_round_mask:
5582 case X86::BI__builtin_ia32_reducepd512_mask:
5583 case X86::BI__builtin_ia32_reduceps512_mask:
5584 case X86::BI__builtin_ia32_reduceph512_mask:
5585 case X86::BI__builtin_ia32_rndscalepd_mask:
5586 case X86::BI__builtin_ia32_rndscaleps_mask:
5587 case X86::BI__builtin_ia32_rndscaleph_mask:
5588 case X86::BI__builtin_ia32_rsqrt28sd_round_mask:
5589 case X86::BI__builtin_ia32_rsqrt28ss_round_mask:
5592 case X86::BI__builtin_ia32_fixupimmpd512_mask:
5593 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
5594 case X86::BI__builtin_ia32_fixupimmps512_mask:
5595 case X86::BI__builtin_ia32_fixupimmps512_maskz:
5596 case X86::BI__builtin_ia32_fixupimmsd_mask:
5597 case X86::BI__builtin_ia32_fixupimmsd_maskz:
5598 case X86::BI__builtin_ia32_fixupimmss_mask:
5599 case X86::BI__builtin_ia32_fixupimmss_maskz:
5600 case X86::BI__builtin_ia32_getmantsd_round_mask:
5601 case X86::BI__builtin_ia32_getmantss_round_mask:
5602 case X86::BI__builtin_ia32_getmantsh_round_mask:
5603 case X86::BI__builtin_ia32_rangepd512_mask:
5604 case X86::BI__builtin_ia32_rangeps512_mask:
5605 case X86::BI__builtin_ia32_rangesd128_round_mask:
5606 case X86::BI__builtin_ia32_rangess128_round_mask:
5607 case X86::BI__builtin_ia32_reducesd_mask:
5608 case X86::BI__builtin_ia32_reducess_mask:
5609 case X86::BI__builtin_ia32_reducesh_mask:
5610 case X86::BI__builtin_ia32_rndscalesd_round_mask:
5611 case X86::BI__builtin_ia32_rndscaless_round_mask:
5612 case X86::BI__builtin_ia32_rndscalesh_round_mask:
5615 case X86::BI__builtin_ia32_vcvtsd2si64:
5616 case X86::BI__builtin_ia32_vcvtsd2si32:
5617 case X86::BI__builtin_ia32_vcvtsd2usi32:
5618 case X86::BI__builtin_ia32_vcvtsd2usi64:
5619 case X86::BI__builtin_ia32_vcvtss2si32:
5620 case X86::BI__builtin_ia32_vcvtss2si64:
5621 case X86::BI__builtin_ia32_vcvtss2usi32:
5622 case X86::BI__builtin_ia32_vcvtss2usi64:
5623 case X86::BI__builtin_ia32_vcvtsh2si32:
5624 case X86::BI__builtin_ia32_vcvtsh2si64:
5625 case X86::BI__builtin_ia32_vcvtsh2usi32:
5626 case X86::BI__builtin_ia32_vcvtsh2usi64:
5627 case X86::BI__builtin_ia32_sqrtpd512:
5628 case X86::BI__builtin_ia32_sqrtps512:
5629 case X86::BI__builtin_ia32_sqrtph512:
5633 case X86::BI__builtin_ia32_addph512:
5634 case X86::BI__builtin_ia32_divph512:
5635 case X86::BI__builtin_ia32_mulph512:
5636 case X86::BI__builtin_ia32_subph512:
5637 case X86::BI__builtin_ia32_addpd512:
5638 case X86::BI__builtin_ia32_addps512:
5639 case X86::BI__builtin_ia32_divpd512:
5640 case X86::BI__builtin_ia32_divps512:
5641 case X86::BI__builtin_ia32_mulpd512:
5642 case X86::BI__builtin_ia32_mulps512:
5643 case X86::BI__builtin_ia32_subpd512:
5644 case X86::BI__builtin_ia32_subps512:
5645 case X86::BI__builtin_ia32_cvtsi2sd64:
5646 case X86::BI__builtin_ia32_cvtsi2ss32:
5647 case X86::BI__builtin_ia32_cvtsi2ss64:
5648 case X86::BI__builtin_ia32_cvtusi2sd64:
5649 case X86::BI__builtin_ia32_cvtusi2ss32:
5650 case X86::BI__builtin_ia32_cvtusi2ss64:
5651 case X86::BI__builtin_ia32_vcvtusi2sh:
5652 case X86::BI__builtin_ia32_vcvtusi642sh:
5653 case X86::BI__builtin_ia32_vcvtsi2sh:
5654 case X86::BI__builtin_ia32_vcvtsi642sh:
5658 case X86::BI__builtin_ia32_cvtdq2ps512_mask:
5659 case X86::BI__builtin_ia32_cvtudq2ps512_mask:
5660 case X86::BI__builtin_ia32_vcvtpd2ph512_mask:
5661 case X86::BI__builtin_ia32_vcvtps2phx512_mask:
5662 case X86::BI__builtin_ia32_cvtpd2ps512_mask:
5663 case X86::BI__builtin_ia32_cvtpd2dq512_mask:
5664 case X86::BI__builtin_ia32_cvtpd2qq512_mask:
5665 case X86::BI__builtin_ia32_cvtpd2udq512_mask:
5666 case X86::BI__builtin_ia32_cvtpd2uqq512_mask:
5667 case X86::BI__builtin_ia32_cvtps2dq512_mask:
5668 case X86::BI__builtin_ia32_cvtps2qq512_mask:
5669 case X86::BI__builtin_ia32_cvtps2udq512_mask:
5670 case X86::BI__builtin_ia32_cvtps2uqq512_mask:
5671 case X86::BI__builtin_ia32_cvtqq2pd512_mask:
5672 case X86::BI__builtin_ia32_cvtqq2ps512_mask:
5673 case X86::BI__builtin_ia32_cvtuqq2pd512_mask:
5674 case X86::BI__builtin_ia32_cvtuqq2ps512_mask:
5675 case X86::BI__builtin_ia32_vcvtdq2ph512_mask:
5676 case X86::BI__builtin_ia32_vcvtudq2ph512_mask:
5677 case X86::BI__builtin_ia32_vcvtw2ph512_mask:
5678 case X86::BI__builtin_ia32_vcvtuw2ph512_mask:
5679 case X86::BI__builtin_ia32_vcvtph2w512_mask:
5680 case X86::BI__builtin_ia32_vcvtph2uw512_mask:
5681 case X86::BI__builtin_ia32_vcvtph2dq512_mask:
5682 case X86::BI__builtin_ia32_vcvtph2udq512_mask:
5683 case X86::BI__builtin_ia32_vcvtph2qq512_mask:
5684 case X86::BI__builtin_ia32_vcvtph2uqq512_mask:
5685 case X86::BI__builtin_ia32_vcvtqq2ph512_mask:
5686 case X86::BI__builtin_ia32_vcvtuqq2ph512_mask:
5690 case X86::BI__builtin_ia32_addsh_round_mask:
5691 case X86::BI__builtin_ia32_addss_round_mask:
5692 case X86::BI__builtin_ia32_addsd_round_mask:
5693 case X86::BI__builtin_ia32_divsh_round_mask:
5694 case X86::BI__builtin_ia32_divss_round_mask:
5695 case X86::BI__builtin_ia32_divsd_round_mask:
5696 case X86::BI__builtin_ia32_mulsh_round_mask:
5697 case X86::BI__builtin_ia32_mulss_round_mask:
5698 case X86::BI__builtin_ia32_mulsd_round_mask:
5699 case X86::BI__builtin_ia32_subsh_round_mask:
5700 case X86::BI__builtin_ia32_subss_round_mask:
5701 case X86::BI__builtin_ia32_subsd_round_mask:
5702 case X86::BI__builtin_ia32_scalefph512_mask:
5703 case X86::BI__builtin_ia32_scalefpd512_mask:
5704 case X86::BI__builtin_ia32_scalefps512_mask:
5705 case X86::BI__builtin_ia32_scalefsd_round_mask:
5706 case X86::BI__builtin_ia32_scalefss_round_mask:
5707 case X86::BI__builtin_ia32_scalefsh_round_mask:
5708 case X86::BI__builtin_ia32_cvtsd2ss_round_mask:
5709 case X86::BI__builtin_ia32_vcvtss2sh_round_mask:
5710 case X86::BI__builtin_ia32_vcvtsd2sh_round_mask:
5711 case X86::BI__builtin_ia32_sqrtsd_round_mask:
5712 case X86::BI__builtin_ia32_sqrtss_round_mask:
5713 case X86::BI__builtin_ia32_sqrtsh_round_mask:
5714 case X86::BI__builtin_ia32_vfmaddsd3_mask:
5715 case X86::BI__builtin_ia32_vfmaddsd3_maskz:
5716 case X86::BI__builtin_ia32_vfmaddsd3_mask3:
5717 case X86::BI__builtin_ia32_vfmaddss3_mask:
5718 case X86::BI__builtin_ia32_vfmaddss3_maskz:
5719 case X86::BI__builtin_ia32_vfmaddss3_mask3:
5720 case X86::BI__builtin_ia32_vfmaddsh3_mask:
5721 case X86::BI__builtin_ia32_vfmaddsh3_maskz:
5722 case X86::BI__builtin_ia32_vfmaddsh3_mask3:
5723 case X86::BI__builtin_ia32_vfmaddpd512_mask:
5724 case X86::BI__builtin_ia32_vfmaddpd512_maskz:
5725 case X86::BI__builtin_ia32_vfmaddpd512_mask3:
5726 case X86::BI__builtin_ia32_vfmsubpd512_mask3:
5727 case X86::BI__builtin_ia32_vfmaddps512_mask:
5728 case X86::BI__builtin_ia32_vfmaddps512_maskz:
5729 case X86::BI__builtin_ia32_vfmaddps512_mask3:
5730 case X86::BI__builtin_ia32_vfmsubps512_mask3:
5731 case X86::BI__builtin_ia32_vfmaddph512_mask:
5732 case X86::BI__builtin_ia32_vfmaddph512_maskz:
5733 case X86::BI__builtin_ia32_vfmaddph512_mask3:
5734 case X86::BI__builtin_ia32_vfmsubph512_mask3:
5735 case X86::BI__builtin_ia32_vfmaddsubpd512_mask:
5736 case X86::BI__builtin_ia32_vfmaddsubpd512_maskz:
5737 case X86::BI__builtin_ia32_vfmaddsubpd512_mask3:
5738 case X86::BI__builtin_ia32_vfmsubaddpd512_mask3:
5739 case X86::BI__builtin_ia32_vfmaddsubps512_mask:
5740 case X86::BI__builtin_ia32_vfmaddsubps512_maskz:
5741 case X86::BI__builtin_ia32_vfmaddsubps512_mask3:
5742 case X86::BI__builtin_ia32_vfmsubaddps512_mask3:
5743 case X86::BI__builtin_ia32_vfmaddsubph512_mask:
5744 case X86::BI__builtin_ia32_vfmaddsubph512_maskz:
5745 case X86::BI__builtin_ia32_vfmaddsubph512_mask3:
5746 case X86::BI__builtin_ia32_vfmsubaddph512_mask3:
5747 case X86::BI__builtin_ia32_vfmaddcsh_mask:
5748 case X86::BI__builtin_ia32_vfmaddcsh_round_mask:
5749 case X86::BI__builtin_ia32_vfmaddcsh_round_mask3:
5750 case X86::BI__builtin_ia32_vfmaddcph512_mask:
5751 case X86::BI__builtin_ia32_vfmaddcph512_maskz:
5752 case X86::BI__builtin_ia32_vfmaddcph512_mask3:
5753 case X86::BI__builtin_ia32_vfcmaddcsh_mask:
5754 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask:
5755 case X86::BI__builtin_ia32_vfcmaddcsh_round_mask3:
5756 case X86::BI__builtin_ia32_vfcmaddcph512_mask:
5757 case X86::BI__builtin_ia32_vfcmaddcph512_maskz:
5758 case X86::BI__builtin_ia32_vfcmaddcph512_mask3:
5759 case X86::BI__builtin_ia32_vfmulcsh_mask:
5760 case X86::BI__builtin_ia32_vfmulcph512_mask:
5761 case X86::BI__builtin_ia32_vfcmulcsh_mask:
5762 case X86::BI__builtin_ia32_vfcmulcph512_mask:
5776 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
5785 (!HasRC &&
Result == 12) ||
5786 (HasRC &&
Result.getZExtValue() >= 8 &&
Result.getZExtValue() <= 11))
5789 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_rounding)
5794bool Sema::CheckX86BuiltinGatherScatterScale(
unsigned BuiltinID,
5796 unsigned ArgNum = 0;
5797 switch (BuiltinID) {
5800 case X86::BI__builtin_ia32_gatherpfdpd:
5801 case X86::BI__builtin_ia32_gatherpfdps:
5802 case X86::BI__builtin_ia32_gatherpfqpd:
5803 case X86::BI__builtin_ia32_gatherpfqps:
5804 case X86::BI__builtin_ia32_scatterpfdpd:
5805 case X86::BI__builtin_ia32_scatterpfdps:
5806 case X86::BI__builtin_ia32_scatterpfqpd:
5807 case X86::BI__builtin_ia32_scatterpfqps:
5810 case X86::BI__builtin_ia32_gatherd_pd:
5811 case X86::BI__builtin_ia32_gatherd_pd256:
5812 case X86::BI__builtin_ia32_gatherq_pd:
5813 case X86::BI__builtin_ia32_gatherq_pd256:
5814 case X86::BI__builtin_ia32_gatherd_ps:
5815 case X86::BI__builtin_ia32_gatherd_ps256:
5816 case X86::BI__builtin_ia32_gatherq_ps:
5817 case X86::BI__builtin_ia32_gatherq_ps256:
5818 case X86::BI__builtin_ia32_gatherd_q:
5819 case X86::BI__builtin_ia32_gatherd_q256:
5820 case X86::BI__builtin_ia32_gatherq_q:
5821 case X86::BI__builtin_ia32_gatherq_q256:
5822 case X86::BI__builtin_ia32_gatherd_d:
5823 case X86::BI__builtin_ia32_gatherd_d256:
5824 case X86::BI__builtin_ia32_gatherq_d:
5825 case X86::BI__builtin_ia32_gatherq_d256:
5826 case X86::BI__builtin_ia32_gather3div2df:
5827 case X86::BI__builtin_ia32_gather3div2di:
5828 case X86::BI__builtin_ia32_gather3div4df:
5829 case X86::BI__builtin_ia32_gather3div4di:
5830 case X86::BI__builtin_ia32_gather3div4sf:
5831 case X86::BI__builtin_ia32_gather3div4si:
5832 case X86::BI__builtin_ia32_gather3div8sf:
5833 case X86::BI__builtin_ia32_gather3div8si:
5834 case X86::BI__builtin_ia32_gather3siv2df:
5835 case X86::BI__builtin_ia32_gather3siv2di:
5836 case X86::BI__builtin_ia32_gather3siv4df:
5837 case X86::BI__builtin_ia32_gather3siv4di:
5838 case X86::BI__builtin_ia32_gather3siv4sf:
5839 case X86::BI__builtin_ia32_gather3siv4si:
5840 case X86::BI__builtin_ia32_gather3siv8sf:
5841 case X86::BI__builtin_ia32_gather3siv8si:
5842 case X86::BI__builtin_ia32_gathersiv8df:
5843 case X86::BI__builtin_ia32_gathersiv16sf:
5844 case X86::BI__builtin_ia32_gatherdiv8df:
5845 case X86::BI__builtin_ia32_gatherdiv16sf:
5846 case X86::BI__builtin_ia32_gathersiv8di:
5847 case X86::BI__builtin_ia32_gathersiv16si:
5848 case X86::BI__builtin_ia32_gatherdiv8di:
5849 case X86::BI__builtin_ia32_gatherdiv16si:
5850 case X86::BI__builtin_ia32_scatterdiv2df:
5851 case X86::BI__builtin_ia32_scatterdiv2di:
5852 case X86::BI__builtin_ia32_scatterdiv4df:
5853 case X86::BI__builtin_ia32_scatterdiv4di:
5854 case X86::BI__builtin_ia32_scatterdiv4sf:
5855 case X86::BI__builtin_ia32_scatterdiv4si:
5856 case X86::BI__builtin_ia32_scatterdiv8sf:
5857 case X86::BI__builtin_ia32_scatterdiv8si:
5858 case X86::BI__builtin_ia32_scattersiv2df:
5859 case X86::BI__builtin_ia32_scattersiv2di:
5860 case X86::BI__builtin_ia32_scattersiv4df:
5861 case X86::BI__builtin_ia32_scattersiv4di:
5862 case X86::BI__builtin_ia32_scattersiv4sf:
5863 case X86::BI__builtin_ia32_scattersiv4si:
5864 case X86::BI__builtin_ia32_scattersiv8sf:
5865 case X86::BI__builtin_ia32_scattersiv8si:
5866 case X86::BI__builtin_ia32_scattersiv8df:
5867 case X86::BI__builtin_ia32_scattersiv16sf:
5868 case X86::BI__builtin_ia32_scatterdiv8df:
5869 case X86::BI__builtin_ia32_scatterdiv16sf:
5870 case X86::BI__builtin_ia32_scattersiv8di:
5871 case X86::BI__builtin_ia32_scattersiv16si:
5872 case X86::BI__builtin_ia32_scatterdiv8di:
5873 case X86::BI__builtin_ia32_scatterdiv16si:
5886 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
5892 return Diag(TheCall->
getBeginLoc(), diag::err_x86_builtin_invalid_scale)
5898bool Sema::CheckX86BuiltinTileArgumentsRange(
CallExpr *TheCall,
5900 for (
int ArgNum : ArgNums) {
5907bool Sema::CheckX86BuiltinTileDuplicate(
CallExpr *TheCall,
5911 std::bitset<TileRegHigh + 1> ArgValues;
5912 for (
int ArgNum : ArgNums) {
5918 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
5920 int ArgExtValue =
Result.getExtValue();
5922 "Incorrect tile register num.");
5923 if (ArgValues.test(ArgExtValue))
5925 diag::err_x86_builtin_tile_arg_duplicate)
5927 ArgValues.set(ArgExtValue);
5932bool Sema::CheckX86BuiltinTileRangeAndDuplicate(
CallExpr *TheCall,
5934 return CheckX86BuiltinTileArgumentsRange(TheCall, ArgNums) ||
5935 CheckX86BuiltinTileDuplicate(TheCall, ArgNums);
5938bool Sema::CheckX86BuiltinTileArguments(
unsigned BuiltinID,
CallExpr *TheCall) {
5939 switch (BuiltinID) {
5942 case X86::BI__builtin_ia32_tileloadd64:
5943 case X86::BI__builtin_ia32_tileloaddt164:
5944 case X86::BI__builtin_ia32_tilestored64:
5945 case X86::BI__builtin_ia32_tilezero:
5946 return CheckX86BuiltinTileArgumentsRange(TheCall, 0);
5947 case X86::BI__builtin_ia32_tdpbssd:
5948 case X86::BI__builtin_ia32_tdpbsud:
5949 case X86::BI__builtin_ia32_tdpbusd:
5950 case X86::BI__builtin_ia32_tdpbuud:
5951 case X86::BI__builtin_ia32_tdpbf16ps:
5952 case X86::BI__builtin_ia32_tdpfp16ps:
5953 case X86::BI__builtin_ia32_tcmmimfp16ps:
5954 case X86::BI__builtin_ia32_tcmmrlfp16ps:
5955 return CheckX86BuiltinTileRangeAndDuplicate(TheCall, {0, 1, 2});
5960 switch (BuiltinID) {
5961 case X86::BI__builtin_ia32_readeflags_u32:
5962 case X86::BI__builtin_ia32_writeeflags_u32:
5969bool Sema::CheckX86BuiltinFunctionCall(
const TargetInfo &TI,
unsigned BuiltinID,
5971 if (BuiltinID == X86::BI__builtin_cpu_supports)
5974 if (BuiltinID == X86::BI__builtin_cpu_is)
5978 const llvm::Triple &TT = TI.
getTriple();
5981 diag::err_32_bit_builtin_64_bit_tgt);
5984 if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))
5988 if (CheckX86BuiltinGatherScatterScale(BuiltinID, TheCall))
5992 if (CheckX86BuiltinTileArguments(BuiltinID, TheCall))
5997 int i = 0, l = 0, u = 0;
5998 switch (BuiltinID) {
6001 case X86::BI__builtin_ia32_vec_ext_v2si:
6002 case X86::BI__builtin_ia32_vec_ext_v2di:
6003 case X86::BI__builtin_ia32_vextractf128_pd256:
6004 case X86::BI__builtin_ia32_vextractf128_ps256:
6005 case X86::BI__builtin_ia32_vextractf128_si256:
6006 case X86::BI__builtin_ia32_extract128i256:
6007 case X86::BI__builtin_ia32_extractf64x4_mask:
6008 case X86::BI__builtin_ia32_extracti64x4_mask:
6009 case X86::BI__builtin_ia32_extractf32x8_mask:
6010 case X86::BI__builtin_ia32_extracti32x8_mask:
6011 case X86::BI__builtin_ia32_extractf64x2_256_mask:
6012 case X86::BI__builtin_ia32_extracti64x2_256_mask:
6013 case X86::BI__builtin_ia32_extractf32x4_256_mask:
6014 case X86::BI__builtin_ia32_extracti32x4_256_mask:
6015 i = 1; l = 0; u = 1;
6017 case X86::BI__builtin_ia32_vec_set_v2di:
6018 case X86::BI__builtin_ia32_vinsertf128_pd256:
6019 case X86::BI__builtin_ia32_vinsertf128_ps256:
6020 case X86::BI__builtin_ia32_vinsertf128_si256:
6021 case X86::BI__builtin_ia32_insert128i256:
6022 case X86::BI__builtin_ia32_insertf32x8:
6023 case X86::BI__builtin_ia32_inserti32x8:
6024 case X86::BI__builtin_ia32_insertf64x4:
6025 case X86::BI__builtin_ia32_inserti64x4:
6026 case X86::BI__builtin_ia32_insertf64x2_256:
6027 case X86::BI__builtin_ia32_inserti64x2_256:
6028 case X86::BI__builtin_ia32_insertf32x4_256:
6029 case X86::BI__builtin_ia32_inserti32x4_256:
6030 i = 2; l = 0; u = 1;
6032 case X86::BI__builtin_ia32_vpermilpd:
6033 case X86::BI__builtin_ia32_vec_ext_v4hi:
6034 case X86::BI__builtin_ia32_vec_ext_v4si:
6035 case X86::BI__builtin_ia32_vec_ext_v4sf:
6036 case X86::BI__builtin_ia32_vec_ext_v4di:
6037 case X86::BI__builtin_ia32_extractf32x4_mask:
6038 case X86::BI__builtin_ia32_extracti32x4_mask:
6039 case X86::BI__builtin_ia32_extractf64x2_512_mask:
6040 case X86::BI__builtin_ia32_extracti64x2_512_mask:
6041 i = 1; l = 0; u = 3;
6043 case X86::BI_mm_prefetch:
6044 case X86::BI__builtin_ia32_vec_ext_v8hi:
6045 case X86::BI__builtin_ia32_vec_ext_v8si:
6046 i = 1; l = 0; u = 7;
6048 case X86::BI__builtin_ia32_sha1rnds4:
6049 case X86::BI__builtin_ia32_blendpd:
6050 case X86::BI__builtin_ia32_shufpd:
6051 case X86::BI__builtin_ia32_vec_set_v4hi:
6052 case X86::BI__builtin_ia32_vec_set_v4si:
6053 case X86::BI__builtin_ia32_vec_set_v4di:
6054 case X86::BI__builtin_ia32_shuf_f32x4_256:
6055 case X86::BI__builtin_ia32_shuf_f64x2_256:
6056 case X86::BI__builtin_ia32_shuf_i32x4_256:
6057 case X86::BI__builtin_ia32_shuf_i64x2_256:
6058 case X86::BI__builtin_ia32_insertf64x2_512:
6059 case X86::BI__builtin_ia32_inserti64x2_512:
6060 case X86::BI__builtin_ia32_insertf32x4:
6061 case X86::BI__builtin_ia32_inserti32x4:
6062 i = 2; l = 0; u = 3;
6064 case X86::BI__builtin_ia32_vpermil2pd:
6065 case X86::BI__builtin_ia32_vpermil2pd256:
6066 case X86::BI__builtin_ia32_vpermil2ps:
6067 case X86::BI__builtin_ia32_vpermil2ps256:
6068 i = 3; l = 0; u = 3;
6070 case X86::BI__builtin_ia32_cmpb128_mask:
6071 case X86::BI__builtin_ia32_cmpw128_mask:
6072 case X86::BI__builtin_ia32_cmpd128_mask:
6073 case X86::BI__builtin_ia32_cmpq128_mask:
6074 case X86::BI__builtin_ia32_cmpb256_mask:
6075 case X86::BI__builtin_ia32_cmpw256_mask:
6076 case X86::BI__builtin_ia32_cmpd256_mask:
6077 case X86::BI__builtin_ia32_cmpq256_mask:
6078 case X86::BI__builtin_ia32_cmpb512_mask:
6079 case X86::BI__builtin_ia32_cmpw512_mask:
6080 case X86::BI__builtin_ia32_cmpd512_mask:
6081 case X86::BI__builtin_ia32_cmpq512_mask:
6082 case X86::BI__builtin_ia32_ucmpb128_mask:
6083 case X86::BI__builtin_ia32_ucmpw128_mask:
6084 case X86::BI__builtin_ia32_ucmpd128_mask:
6085 case X86::BI__builtin_ia32_ucmpq128_mask:
6086 case X86::BI__builtin_ia32_ucmpb256_mask:
6087 case X86::BI__builtin_ia32_ucmpw256_mask:
6088 case X86::BI__builtin_ia32_ucmpd256_mask:
6089 case X86::BI__builtin_ia32_ucmpq256_mask:
6090 case X86::BI__builtin_ia32_ucmpb512_mask:
6091 case X86::BI__builtin_ia32_ucmpw512_mask:
6092 case X86::BI__builtin_ia32_ucmpd512_mask:
6093 case X86::BI__builtin_ia32_ucmpq512_mask:
6094 case X86::BI__builtin_ia32_vpcomub:
6095 case X86::BI__builtin_ia32_vpcomuw:
6096 case X86::BI__builtin_ia32_vpcomud:
6097 case X86::BI__builtin_ia32_vpcomuq:
6098 case X86::BI__builtin_ia32_vpcomb:
6099 case X86::BI__builtin_ia32_vpcomw:
6100 case X86::BI__builtin_ia32_vpcomd:
6101 case X86::BI__builtin_ia32_vpcomq:
6102 case X86::BI__builtin_ia32_vec_set_v8hi:
6103 case X86::BI__builtin_ia32_vec_set_v8si:
6104 i = 2; l = 0; u = 7;
6106 case X86::BI__builtin_ia32_vpermilpd256:
6107 case X86::BI__builtin_ia32_roundps:
6108 case X86::BI__builtin_ia32_roundpd:
6109 case X86::BI__builtin_ia32_roundps256:
6110 case X86::BI__builtin_ia32_roundpd256:
6111 case X86::BI__builtin_ia32_getmantpd128_mask:
6112 case X86::BI__builtin_ia32_getmantpd256_mask:
6113 case X86::BI__builtin_ia32_getmantps128_mask:
6114 case X86::BI__builtin_ia32_getmantps256_mask:
6115 case X86::BI__builtin_ia32_getmantpd512_mask:
6116 case X86::BI__builtin_ia32_getmantps512_mask:
6117 case X86::BI__builtin_ia32_getmantph128_mask:
6118 case X86::BI__builtin_ia32_getmantph256_mask:
6119 case X86::BI__builtin_ia32_getmantph512_mask:
6120 case X86::BI__builtin_ia32_vec_ext_v16qi:
6121 case X86::BI__builtin_ia32_vec_ext_v16hi:
6122 i = 1; l = 0; u = 15;
6124 case X86::BI__builtin_ia32_pblendd128:
6125 case X86::BI__builtin_ia32_blendps:
6126 case X86::BI__builtin_ia32_blendpd256:
6127 case X86::BI__builtin_ia32_shufpd256:
6128 case X86::BI__builtin_ia32_roundss:
6129 case X86::BI__builtin_ia32_roundsd:
6130 case X86::BI__builtin_ia32_rangepd128_mask:
6131 case X86::BI__builtin_ia32_rangepd256_mask:
6132 case X86::BI__builtin_ia32_rangepd512_mask:
6133 case X86::BI__builtin_ia32_rangeps128_mask:
6134 case X86::BI__builtin_ia32_rangeps256_mask:
6135 case X86::BI__builtin_ia32_rangeps512_mask:
6136 case X86::BI__builtin_ia32_getmantsd_round_mask:
6137 case X86::BI__builtin_ia32_getmantss_round_mask:
6138 case X86::BI__builtin_ia32_getmantsh_round_mask:
6139 case X86::BI__builtin_ia32_vec_set_v16qi:
6140 case X86::BI__builtin_ia32_vec_set_v16hi:
6141 i = 2; l = 0; u = 15;
6143 case X86::BI__builtin_ia32_vec_ext_v32qi:
6144 i = 1; l = 0; u = 31;
6146 case X86::BI__builtin_ia32_cmpps:
6147 case X86::BI__builtin_ia32_cmpss:
6148 case X86::BI__builtin_ia32_cmppd:
6149 case X86::BI__builtin_ia32_cmpsd:
6150 case X86::BI__builtin_ia32_cmpps256:
6151 case X86::BI__builtin_ia32_cmppd256:
6152 case X86::BI__builtin_ia32_cmpps128_mask:
6153 case X86::BI__builtin_ia32_cmppd128_mask:
6154 case X86::BI__builtin_ia32_cmpps256_mask:
6155 case X86::BI__builtin_ia32_cmppd256_mask:
6156 case X86::BI__builtin_ia32_cmpps512_mask:
6157 case X86::BI__builtin_ia32_cmppd512_mask:
6158 case X86::BI__builtin_ia32_cmpsd_mask:
6159 case X86::BI__builtin_ia32_cmpss_mask:
6160 case X86::BI__builtin_ia32_vec_set_v32qi:
6161 i = 2; l = 0; u = 31;
6163 case X86::BI__builtin_ia32_permdf256:
6164 case X86::BI__builtin_ia32_permdi256:
6165 case X86::BI__builtin_ia32_permdf512:
6166 case X86::BI__builtin_ia32_permdi512:
6167 case X86::BI__builtin_ia32_vpermilps:
6168 case X86::BI__builtin_ia32_vpermilps256:
6169 case X86::BI__builtin_ia32_vpermilpd512:
6170 case X86::BI__builtin_ia32_vpermilps512:
6171 case X86::BI__builtin_ia32_pshufd:
6172 case X86::BI__builtin_ia32_pshufd256:
6173 case X86::BI__builtin_ia32_pshufd512:
6174 case X86::BI__builtin_ia32_pshufhw:
6175 case X86::BI__builtin_ia32_pshufhw256:
6176 case X86::BI__builtin_ia32_pshufhw512:
6177 case X86::BI__builtin_ia32_pshuflw:
6178 case X86::BI__builtin_ia32_pshuflw256:
6179 case X86::BI__builtin_ia32_pshuflw512:
6180 case X86::BI__builtin_ia32_vcvtps2ph:
6181 case X86::BI__builtin_ia32_vcvtps2ph_mask:
6182 case X86::BI__builtin_ia32_vcvtps2ph256:
6183 case X86::BI__builtin_ia32_vcvtps2ph256_mask:
6184 case X86::BI__builtin_ia32_vcvtps2ph512_mask:
6185 case X86::BI__builtin_ia32_rndscaleps_128_mask:
6186 case X86::BI__builtin_ia32_rndscalepd_128_mask:
6187 case X86::BI__builtin_ia32_rndscaleps_256_mask:
6188 case X86::BI__builtin_ia32_rndscalepd_256_mask:
6189 case X86::BI__builtin_ia32_rndscaleps_mask:
6190 case X86::BI__builtin_ia32_rndscalepd_mask:
6191 case X86::BI__builtin_ia32_rndscaleph_mask:
6192 case X86::BI__builtin_ia32_reducepd128_mask:
6193 case X86::BI__builtin_ia32_reducepd256_mask:
6194 case X86::BI__builtin_ia32_reducepd512_mask:
6195 case X86::BI__builtin_ia32_reduceps128_mask:
6196 case X86::BI__builtin_ia32_reduceps256_mask:
6197 case X86::BI__builtin_ia32_reduceps512_mask:
6198 case X86::BI__builtin_ia32_reduceph128_mask:
6199 case X86::BI__builtin_ia32_reduceph256_mask:
6200 case X86::BI__builtin_ia32_reduceph512_mask:
6201 case X86::BI__builtin_ia32_prold512:
6202 case X86::BI__builtin_ia32_prolq512:
6203 case X86::BI__builtin_ia32_prold128:
6204 case X86::BI__builtin_ia32_prold256:
6205 case X86::BI__builtin_ia32_prolq128:
6206 case X86::BI__builtin_ia32_prolq256:
6207 case X86::BI__builtin_ia32_prord512:
6208 case X86::BI__builtin_ia32_prorq512:
6209 case X86::BI__builtin_ia32_prord128:
6210 case X86::BI__builtin_ia32_prord256:
6211 case X86::BI__builtin_ia32_prorq128:
6212 case X86::BI__builtin_ia32_prorq256:
6213 case X86::BI__builtin_ia32_fpclasspd128_mask:
6214 case X86::BI__builtin_ia32_fpclasspd256_mask:
6215 case X86::BI__builtin_ia32_fpclassps128_mask:
6216 case X86::BI__builtin_ia32_fpclassps256_mask:
6217 case X86::BI__builtin_ia32_fpclassps512_mask:
6218 case X86::BI__builtin_ia32_fpclasspd512_mask:
6219 case X86::BI__builtin_ia32_fpclassph128_mask:
6220 case X86::BI__builtin_ia32_fpclassph256_mask:
6221 case X86::BI__builtin_ia32_fpclassph512_mask:
6222 case X86::BI__builtin_ia32_fpclasssd_mask:
6223 case X86::BI__builtin_ia32_fpclassss_mask:
6224 case X86::BI__builtin_ia32_fpclasssh_mask:
6225 case X86::BI__builtin_ia32_pslldqi128_byteshift:
6226 case X86::BI__builtin_ia32_pslldqi256_byteshift:
6227 case X86::BI__builtin_ia32_pslldqi512_byteshift:
6228 case X86::BI__builtin_ia32_psrldqi128_byteshift:
6229 case X86::BI__builtin_ia32_psrldqi256_byteshift:
6230 case X86::BI__builtin_ia32_psrldqi512_byteshift:
6231 case X86::BI__builtin_ia32_kshiftliqi:
6232 case X86::BI__builtin_ia32_kshiftlihi:
6233 case X86::BI__builtin_ia32_kshiftlisi:
6234 case X86::BI__builtin_ia32_kshiftlidi:
6235 case X86::BI__builtin_ia32_kshiftriqi:
6236 case X86::BI__builtin_ia32_kshiftrihi:
6237 case X86::BI__builtin_ia32_kshiftrisi:
6238 case X86::BI__builtin_ia32_kshiftridi:
6239 i = 1; l = 0; u = 255;
6241 case X86::BI__builtin_ia32_vperm2f128_pd256:
6242 case X86::BI__builtin_ia32_vperm2f128_ps256:
6243 case X86::BI__builtin_ia32_vperm2f128_si256:
6244 case X86::BI__builtin_ia32_permti256:
6245 case X86::BI__builtin_ia32_pblendw128:
6246 case X86::BI__builtin_ia32_pblendw256:
6247 case X86::BI__builtin_ia32_blendps256:
6248 case X86::BI__builtin_ia32_pblendd256:
6249 case X86::BI__builtin_ia32_palignr128:
6250 case X86::BI__builtin_ia32_palignr256:
6251 case X86::BI__builtin_ia32_palignr512:
6252 case X86::BI__builtin_ia32_alignq512:
6253 case X86::BI__builtin_ia32_alignd512:
6254 case X86::BI__builtin_ia32_alignd128:
6255 case X86::BI__builtin_ia32_alignd256:
6256 case X86::BI__builtin_ia32_alignq128:
6257 case X86::BI__builtin_ia32_alignq256:
6258 case X86::BI__builtin_ia32_vcomisd:
6259 case X86::BI__builtin_ia32_vcomiss:
6260 case X86::BI__builtin_ia32_shuf_f32x4:
6261 case X86::BI__builtin_ia32_shuf_f64x2:
6262 case X86::BI__builtin_ia32_shuf_i32x4:
6263 case X86::BI__builtin_ia32_shuf_i64x2:
6264 case X86::BI__builtin_ia32_shufpd512:
6265 case X86::BI__builtin_ia32_shufps:
6266 case X86::BI__builtin_ia32_shufps256:
6267 case X86::BI__builtin_ia32_shufps512:
6268 case X86::BI__builtin_ia32_dbpsadbw128:
6269 case X86::BI__builtin_ia32_dbpsadbw256:
6270 case X86::BI__builtin_ia32_dbpsadbw512:
6271 case X86::BI__builtin_ia32_vpshldd128:
6272 case X86::BI__builtin_ia32_vpshldd256:
6273 case X86::BI__builtin_ia32_vpshldd512:
6274 case X86::BI__builtin_ia32_vpshldq128:
6275 case X86::BI__builtin_ia32_vpshldq256:
6276 case X86::BI__builtin_ia32_vpshldq512:
6277 case X86::BI__builtin_ia32_vpshldw128:
6278 case X86::BI__builtin_ia32_vpshldw256:
6279 case X86::BI__builtin_ia32_vpshldw512:
6280 case X86::BI__builtin_ia32_vpshrdd128:
6281 case X86::BI__builtin_ia32_vpshrdd256:
6282 case X86::BI__builtin_ia32_vpshrdd512:
6283 case X86::BI__builtin_ia32_vpshrdq128:
6284 case X86::BI__builtin_ia32_vpshrdq256:
6285 case X86::BI__builtin_ia32_vpshrdq512:
6286 case X86::BI__builtin_ia32_vpshrdw128:
6287 case X86::BI__builtin_ia32_vpshrdw256:
6288 case X86::BI__builtin_ia32_vpshrdw512:
6289 i = 2; l = 0; u = 255;
6291 case X86::BI__builtin_ia32_fixupimmpd512_mask:
6292 case X86::BI__builtin_ia32_fixupimmpd512_maskz:
6293 case X86::BI__builtin_ia32_fixupimmps512_mask:
6294 case X86::BI__builtin_ia32_fixupimmps512_maskz:
6295 case X86::BI__builtin_ia32_fixupimmsd_mask:
6296 case X86::BI__builtin_ia32_fixupimmsd_maskz:
6297 case X86::BI__builtin_ia32_fixupimmss_mask:
6298 case X86::BI__builtin_ia32_fixupimmss_maskz:
6299 case X86::BI__builtin_ia32_fixupimmpd128_mask:
6300 case X86::BI__builtin_ia32_fixupimmpd128_maskz:
6301 case X86::BI__builtin_ia32_fixupimmpd256_mask:
6302 case X86::BI__builtin_ia32_fixupimmpd256_maskz:
6303 case X86::BI__builtin_ia32_fixupimmps128_mask:
6304 case X86::BI__builtin_ia32_fixupimmps128_maskz:
6305 case X86::BI__builtin_ia32_fixupimmps256_mask:
6306 case X86::BI__builtin_ia32_fixupimmps256_maskz:
6307 case X86::BI__builtin_ia32_pternlogd512_mask:
6308 case X86::BI__builtin_ia32_pternlogd512_maskz:
6309 case X86::BI__builtin_ia32_pternlogq512_mask:
6310 case X86::BI__builtin_ia32_pternlogq512_maskz:
6311 case X86::BI__builtin_ia32_pternlogd128_mask:
6312 case X86::BI__builtin_ia32_pternlogd128_maskz:
6313 case X86::BI__builtin_ia32_pternlogd256_mask:
6314 case X86::BI__builtin_ia32_pternlogd256_maskz:
6315 case X86::BI__builtin_ia32_pternlogq128_mask:
6316 case X86::BI__builtin_ia32_pternlogq128_maskz:
6317 case X86::BI__builtin_ia32_pternlogq256_mask:
6318 case X86::BI__builtin_ia32_pternlogq256_maskz:
6319 case X86::BI__builtin_ia32_vsm3rnds2:
6320 i = 3; l = 0; u = 255;
6322 case X86::BI__builtin_ia32_gatherpfdpd:
6323 case X86::BI__builtin_ia32_gatherpfdps:
6324 case X86::BI__builtin_ia32_gatherpfqpd:
6325 case X86::BI__builtin_ia32_gatherpfqps:
6326 case X86::BI__builtin_ia32_scatterpfdpd:
6327 case X86::BI__builtin_ia32_scatterpfdps:
6328 case X86::BI__builtin_ia32_scatterpfqpd:
6329 case X86::BI__builtin_ia32_scatterpfqps:
6330 i = 4; l = 2; u = 3;
6332 case X86::BI__builtin_ia32_reducesd_mask:
6333 case X86::BI__builtin_ia32_reducess_mask:
6334 case X86::BI__builtin_ia32_rndscalesd_round_mask:
6335 case X86::BI__builtin_ia32_rndscaless_round_mask:
6336 case X86::BI__builtin_ia32_rndscalesh_round_mask:
6337 case X86::BI__builtin_ia32_reducesh_mask:
6338 i = 4; l = 0; u = 255;
6340 case X86::BI__builtin_ia32_cmpccxadd32:
6341 case X86::BI__builtin_ia32_cmpccxadd64:
6342 i = 3; l = 0; u = 15;
6350 return SemaBuiltinConstantArgRange(TheCall, i, l, u,
false);
6359 if (Format->getFirstArg() == 0)
6361 else if (IsVariadic)
6365 FSI->
FormatIdx = Format->getFormatIdx() - 1;
6395 if (UT->getDecl()->hasAttr<TransparentUnionAttr>())
6397 dyn_cast<CompoundLiteralExpr>(
Expr))
6399 dyn_cast<InitListExpr>(CLE->getInitializer()))
6400 Expr = ILE->getInit(0);
6410 const Expr *ArgExpr,
6414 S.
PDiag(diag::warn_null_arg)
6436 bool Format =
false;
6449 if (!Format || NumArgs <= Idx)
6451 const Expr *FormatExpr = Args[Idx];
6452 if (
const CStyleCastExpr *CSCE = dyn_cast<CStyleCastExpr>(FormatExpr))
6453 FormatExpr = CSCE->getSubExpr();
6463 S.
Diag(FormatExpr->
getExprLoc(), diag::warn_objc_cdirective_format_string)
6472 if (
auto nullability = type->getNullability())
6483 assert((FDecl || Proto) &&
"Need a function declaration or prototype");
6489 llvm::SmallBitVector NonNullArgs;
6495 for (
const auto *Arg : Args)
6502 unsigned IdxAST = Idx.getASTIndex();
6503 if (IdxAST >= Args.size())
6505 if (NonNullArgs.empty())
6506 NonNullArgs.resize(Args.size());
6507 NonNullArgs.set(IdxAST);
6512 if (FDecl && (isa<FunctionDecl>(FDecl) || isa<ObjCMethodDecl>(FDecl))) {
6516 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(FDecl))
6521 unsigned ParamIndex = 0;
6523 I != E; ++I, ++ParamIndex) {
6526 if (NonNullArgs.empty())
6527 NonNullArgs.resize(Args.size());
6529 NonNullArgs.set(ParamIndex);
6536 if (
const ValueDecl *VD = dyn_cast<ValueDecl>(FDecl)) {
6537 QualType type = VD->getType().getNonReferenceType();
6555 if (NonNullArgs.empty())
6556 NonNullArgs.resize(Args.size());
6558 NonNullArgs.set(Index);
6567 for (
unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
6568 ArgIndex != ArgIndexEnd; ++ArgIndex) {
6569 if (NonNullArgs[ArgIndex])
6582 const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg->
IgnoreParens());
6586 const auto *DR = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
6590 const auto *PD = dyn_cast<ParmVarDecl>(DR->getDecl());
6591 if (!PD || !PD->getType()->isRecordType())
6596 ArgType->castAs<RecordType>()->getDecl()->fields()) {
6597 if (
const auto *AA = FD->
getAttr<AlignedAttr>()) {
6602 Diag(Loc, diag::note_misaligned_member_used_here) << PD;
6613 StringRef ParamName,
QualType ArgTy,
6641 if (ArgAlign < ParamAlign)
6642 Diag(Loc, diag::warn_param_mismatched_alignment)
6644 << ParamName << (FDecl !=
nullptr) << FDecl;
6659 llvm::SmallBitVector CheckedVarArgs;
6663 CheckedVarArgs.resize(Args.size());
6665 CheckFormatArguments(I, Args, IsMemberFunction, CallType, Loc, Range,
6672 auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
6682 for (
unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
6684 if (
const Expr *Arg = Args[ArgIdx]) {
6685 if (CheckedVarArgs.empty() || !CheckedVarArgs[ArgIdx])
6691 if (FDecl || Proto) {
6696 for (
const auto *I : FDecl->
specific_attrs<ArgumentWithTypeTagAttr>())
6697 CheckArgumentWithTypeTag(I, Args, Loc);
6703 if (!Proto && FDecl) {
6705 if (isa_and_nonnull<FunctionProtoType>(FT))
6711 const auto N = std::min<unsigned>(Proto->
getNumParams(), Args.size());
6712 for (
unsigned ArgIdx = 0; ArgIdx <
N; ++ArgIdx) {
6714 if (
const Expr *Arg = Args[ArgIdx]) {
6722 checkAIXMemberAlignment((Arg->
getExprLoc()), Arg);
6726 CheckArgAlignment(Arg->
getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
6732 if (FDecl && FDecl->
hasAttr<AllocAlignAttr>()) {
6733 auto *AA = FDecl->
getAttr<AllocAlignAttr>();
6734 const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
6735 if (!Arg->isValueDependent()) {
6737 if (Arg->EvaluateAsInt(Align,
Context)) {
6738 const llvm::APSInt &I = Align.
Val.
getInt();
6739 if (!I.isPowerOf2())
6740 Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
6741 << Arg->getSourceRange();
6744 Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
6767 checkCall(FDecl, Proto,
nullptr, Args,
true,
6778 IsMemberOperatorCall;
6784 Expr *ImplicitThis =
nullptr;
6785 if (IsMemberOperatorCall && !FDecl->
isStatic()) {
6789 ImplicitThis = Args[0];
6792 }
else if (IsMemberFunction && !FDecl->
isStatic())
6808 CheckArgAlignment(TheCall->
getRParenLoc(), FDecl,
"'this'", ThisType,
6812 checkCall(FDecl, Proto, ImplicitThis,
llvm::ArrayRef(Args, NumArgs),
6824 CheckTCBEnforcement(TheCall->
getExprLoc(), FDecl);
6826 CheckAbsoluteValueFunction(TheCall, FDecl);
6827 CheckMaxUnsignedZero(TheCall, FDecl);
6838 case Builtin::BIstrlcpy:
6839 case Builtin::BIstrlcat:
6840 CheckStrlcpycatArguments(TheCall, FnInfo);
6842 case Builtin::BIstrncat:
6843 CheckStrncatArguments(TheCall, FnInfo);
6845 case Builtin::BIfree:
6846 CheckFreeArguments(TheCall);
6849 CheckMemaccessArguments(TheCall, CMId, FnInfo);
6860 checkCall(Method,
nullptr,
nullptr, Args,
6861 false, lbrac, Method->getSourceRange(),
6864 CheckTCBEnforcement(lbrac, Method);
6872 if (
const auto *
V = dyn_cast<VarDecl>(NDecl))
6873 Ty =
V->getType().getNonReferenceType();
6874 else if (
const auto *F = dyn_cast<FieldDecl>(NDecl))
6875 Ty = F->getType().getNonReferenceType();
6892 checkCall(NDecl, Proto,
nullptr,
6905 checkCall(
nullptr, Proto,
nullptr,
6914 if (!llvm::isValidAtomicOrderingCABI(Ordering))
6917 auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
6919 case AtomicExpr::AO__c11_atomic_init:
6920 case AtomicExpr::AO__opencl_atomic_init:
6921 llvm_unreachable(
"There is no ordering argument for an init");
6923 case AtomicExpr::AO__c11_atomic_load:
6924 case AtomicExpr::AO__opencl_atomic_load:
6925 case AtomicExpr::AO__hip_atomic_load:
6926 case AtomicExpr::AO__atomic_load_n:
6927 case AtomicExpr::AO__atomic_load:
6928 return OrderingCABI != llvm::AtomicOrderingCABI::release &&
6929 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
6931 case AtomicExpr::AO__c11_atomic_store:
6932 case AtomicExpr::AO__opencl_atomic_store:
6933 case AtomicExpr::AO__hip_atomic_store:
6934 case AtomicExpr::AO__atomic_store:
6935 case AtomicExpr::AO__atomic_store_n:
6936 return OrderingCABI != llvm::AtomicOrderingCABI::consume &&
6937 OrderingCABI != llvm::AtomicOrderingCABI::acquire &&
6938 OrderingCABI != llvm::AtomicOrderingCABI::acq_rel;
6991 const unsigned NumForm = GNUCmpXchg + 1;
6992 const unsigned NumArgs[] = { 2, 2, 3, 3, 3, 3, 4, 5, 6 };
6993 const unsigned NumVals[] = { 1, 0, 1, 1, 1, 1, 2, 2, 3 };
7001 static_assert(
sizeof(NumArgs)/
sizeof(NumArgs[0]) == NumForm
7002 &&
sizeof(NumVals)/
sizeof(NumVals[0]) == NumForm,
7003 "need to update code for modified forms");
7004 static_assert(AtomicExpr::AO__c11_atomic_init == 0 &&
7005 AtomicExpr::AO__c11_atomic_fetch_min + 1 ==
7006 AtomicExpr::AO__atomic_load,
7007 "need to update code for modified C11 atomics");
7008 bool IsOpenCL = Op >= AtomicExpr::AO__opencl_atomic_init &&
7009 Op <= AtomicExpr::AO__opencl_atomic_fetch_max;
7010 bool IsHIP = Op >= AtomicExpr::AO__hip_atomic_load &&
7011 Op <= AtomicExpr::AO__hip_atomic_fetch_max;
7012 bool IsC11 = (Op >= AtomicExpr::AO__c11_atomic_init &&
7013 Op <= AtomicExpr::AO__c11_atomic_fetch_min) ||
7015 bool IsN = Op == AtomicExpr::AO__atomic_load_n ||
7016 Op == AtomicExpr::AO__atomic_store_n ||
7017 Op == AtomicExpr::AO__atomic_exchange_n ||
7018 Op == AtomicExpr::AO__atomic_compare_exchange_n;
7022 enum ArithOpExtraValueType {
7027 unsigned ArithAllows = AOEVT_None;
7030 case AtomicExpr::AO__c11_atomic_init:
7031 case AtomicExpr::AO__opencl_atomic_init:
7035 case AtomicExpr::AO__c11_atomic_load:
7036 case AtomicExpr::AO__opencl_atomic_load:
7037 case AtomicExpr::AO__hip_atomic_load:
7038 case AtomicExpr::AO__atomic_load_n:
7042 case AtomicExpr::AO__atomic_load:
7046 case AtomicExpr::AO__c11_atomic_store:
7047 case AtomicExpr::AO__opencl_atomic_store:
7048 case AtomicExpr::AO__hip_atomic_store:
7049 case AtomicExpr::AO__atomic_store:
7050 case AtomicExpr::AO__atomic_store_n:
7053 case AtomicExpr::AO__atomic_fetch_add:
7054 case AtomicExpr::AO__atomic_fetch_sub:
7055 case AtomicExpr::AO__atomic_add_fetch:
7056 case AtomicExpr::AO__atomic_sub_fetch:
7057 case AtomicExpr::AO__c11_atomic_fetch_add:
7058 case AtomicExpr::AO__c11_atomic_fetch_sub:
7059 case AtomicExpr::AO__opencl_atomic_fetch_add:
7060 case AtomicExpr::AO__opencl_atomic_fetch_sub:
7061 case AtomicExpr::AO__hip_atomic_fetch_add:
7062 case AtomicExpr::AO__hip_atomic_fetch_sub:
7063 ArithAllows = AOEVT_Pointer | AOEVT_FP;
7066 case AtomicExpr::AO__atomic_fetch_max:
7067 case AtomicExpr::AO__atomic_fetch_min:
7068 case AtomicExpr::AO__atomic_max_fetch:
7069 case AtomicExpr::AO__atomic_min_fetch:
7070 case AtomicExpr::AO__c11_atomic_fetch_max:
7071 case AtomicExpr::AO__c11_atomic_fetch_min:
7072 case AtomicExpr::AO__opencl_atomic_fetch_max:
7073 case AtomicExpr::AO__opencl_atomic_fetch_min:
7074 case AtomicExpr::AO__hip_atomic_fetch_max:
7075 case AtomicExpr::AO__hip_atomic_fetch_min:
7076 ArithAllows = AOEVT_FP;
7079 case AtomicExpr::AO__c11_atomic_fetch_and:
7080 case AtomicExpr::AO__c11_atomic_fetch_or:
7081 case AtomicExpr::AO__c11_atomic_fetch_xor:
7082 case AtomicExpr::AO__hip_atomic_fetch_and:
7083 case AtomicExpr::AO__hip_atomic_fetch_or:
7084 case AtomicExpr::AO__hip_atomic_fetch_xor:
7085 case AtomicExpr::AO__c11_atomic_fetch_nand:
7086 case AtomicExpr::AO__opencl_atomic_fetch_and:
7087 case AtomicExpr::AO__opencl_atomic_fetch_or:
7088 case AtomicExpr::AO__opencl_atomic_fetch_xor:
7089 case AtomicExpr::AO__atomic_fetch_and:
7090 case AtomicExpr::AO__atomic_fetch_or:
7091 case AtomicExpr::AO__atomic_fetch_xor:
7092 case AtomicExpr::AO__atomic_fetch_nand:
7093 case AtomicExpr::AO__atomic_and_fetch:
7094 case AtomicExpr::AO__atomic_or_fetch:
7095 case AtomicExpr::AO__atomic_xor_fetch:
7096 case AtomicExpr::AO__atomic_nand_fetch:
7100 case AtomicExpr::AO__c11_atomic_exchange:
7101 case AtomicExpr::AO__hip_atomic_exchange:
7102 case AtomicExpr::AO__opencl_atomic_exchange:
7103 case AtomicExpr::AO__atomic_exchange_n:
7107 case AtomicExpr::AO__atomic_exchange:
7111 case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
7112 case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
7113 case AtomicExpr::AO__hip_atomic_compare_exchange_strong:
7114 case AtomicExpr::AO__opencl_atomic_compare_exchange_strong:
7115 case AtomicExpr::AO__opencl_atomic_compare_exchange_weak:
7116 case AtomicExpr::AO__hip_atomic_compare_exchange_weak:
7120 case AtomicExpr::AO__atomic_compare_exchange:
7121 case AtomicExpr::AO__atomic_compare_exchange_n:
7126 unsigned AdjustedNumArgs = NumArgs[Form];
7127 if ((IsOpenCL || IsHIP) && Op != AtomicExpr::AO__opencl_atomic_init)
7130 if (Args.size() < AdjustedNumArgs) {
7131 Diag(CallRange.
getEnd(), diag::err_typecheck_call_too_few_args)
7132 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
7135 }
else if (Args.size() > AdjustedNumArgs) {
7136 Diag(Args[AdjustedNumArgs]->getBeginLoc(),
7137 diag::err_typecheck_call_too_many_args)
7138 << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
7144 Expr *Ptr = Args[0];
7149 Ptr = ConvertedPtr.
get();
7152 Diag(ExprRange.
getBegin(), diag::err_atomic_builtin_must_be_pointer)
7162 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic)
7168 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_atomic)
7174 }
else if (Form != Load && Form != LoadCopy) {
7176 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_non_const_pointer)
7183 if (Form == Arithmetic) {
7186 auto IsAllowedValueType = [&](
QualType ValType,
7187 unsigned AllowedType) ->
bool {
7191 return AllowedType & AOEVT_Pointer;
7197 &llvm::APFloat::x87DoubleExtended())
7201 if (!IsAllowedValueType(ValType, ArithAllows)) {
7202 auto DID = ArithAllows & AOEVT_FP
7203 ? (ArithAllows & AOEVT_Pointer
7204 ? diag::err_atomic_op_needs_atomic_int_ptr_or_fp
7205 : diag::err_atomic_op_needs_atomic_int_or_fp)
7206 : diag::err_atomic_op_needs_atomic_int;
7213 diag::err_incomplete_type)) {
7219 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_atomic_int_or_ptr)
7230 Diag(ExprRange.
getBegin(), diag::err_atomic_op_needs_trivial_copy)
7246 Diag(ExprRange.
getBegin(), diag::err_arc_atomic_ownership)
7258 if (Form ==
Copy || Form == LoadCopy || Form == GNUXchg ||
7261 else if (Form == C11CmpXchg || Form == GNUCmpXchg)
7267 bool IsPassedByAddress =
false;
7268 if (!IsC11 && !IsHIP && !IsN) {
7270 IsPassedByAddress =
true;
7275 APIOrderedArgs.push_back(Args[0]);
7279 APIOrderedArgs.push_back(Args[1]);
7285 APIOrderedArgs.push_back(Args[2]);
7286 APIOrderedArgs.push_back(Args[1]);
7289 APIOrderedArgs.push_back(Args[2]);
7290 APIOrderedArgs.push_back(Args[3]);
7291 APIOrderedArgs.push_back(Args[1]);
7294 APIOrderedArgs.push_back(Args[2]);
7295 APIOrderedArgs.push_back(Args[4]);
7296 APIOrderedArgs.push_back(Args[1]);
7297 APIOrderedArgs.push_back(Args[3]);
7300 APIOrderedArgs.push_back(Args[2]);
7301 APIOrderedArgs.push_back(Args[4]);
7302 APIOrderedArgs.push_back(Args[5]);
7303 APIOrderedArgs.push_back(Args[1]);
7304 APIOrderedArgs.push_back(Args[3]);
7308 APIOrderedArgs.append(Args.begin(), Args.end());
7315 for (
unsigned i = 0; i != APIOrderedArgs.size(); ++i) {
7317 if (i < NumVals[Form] + 1) {
7330 assert(Form != Load);
7333 else if (Form == Init || Form == Arithmetic)
7335 else if (Form ==
Copy || Form == Xchg) {
7336 if (IsPassedByAddress) {
7343 Expr *ValArg = APIOrderedArgs[i];
7350 AS = PtrTy->getPointeeType().getAddressSpace();
7359 if (IsPassedByAddress)
7379 APIOrderedArgs[i] = Arg.
get();
7384 SubExprs.push_back(Ptr);
7388 SubExprs.push_back(APIOrderedArgs[1]);
7391 SubExprs.push_back(APIOrderedArgs[1]);
7397 SubExprs.push_back(APIOrderedArgs[2]);
7398 SubExprs.push_back(APIOrderedArgs[1]);
7402 SubExprs.push_back(APIOrderedArgs[3]);
7403 SubExprs.push_back(APIOrderedArgs[1]);
7404 SubExprs.push_back(APIOrderedArgs[2]);
7407 SubExprs.push_back(APIOrderedArgs[3]);
7408 SubExprs.push_back(APIOrderedArgs[1]);
7409 SubExprs.push_back(APIOrderedArgs[4]);
7410 SubExprs.push_back(APIOrderedArgs[2]);
7413 SubExprs.push_back(APIOrderedArgs[4]);
7414 SubExprs.push_back(APIOrderedArgs[1]);
7415 SubExprs.push_back(APIOrderedArgs[5]);
7416 SubExprs.push_back(APIOrderedArgs[2]);
7417 SubExprs.push_back(APIOrderedArgs[3]);
7421 if (SubExprs.size() >= 2 && Form != Init) {
7422 if (std::optional<llvm::APSInt>
Result =
7423 SubExprs[1]->getIntegerConstantExpr(
Context))
7425 Diag(SubExprs[1]->getBeginLoc(),
7426 diag::warn_atomic_op_has_invalid_memory_order)
7427 << SubExprs[1]->getSourceRange();
7431 auto *
Scope = Args[Args.size() - 1];
7432 if (std::optional<llvm::APSInt>
Result =
7434 if (!ScopeModel->isValid(
Result->getZExtValue()))
7435 Diag(
Scope->getBeginLoc(), diag::err_atomic_op_has_invalid_synch_scope)
7436 <<
Scope->getSourceRange();
7438 SubExprs.push_back(
Scope);
7444 if ((Op == AtomicExpr::AO__c11_atomic_load ||
7445 Op == AtomicExpr::AO__c11_atomic_store ||
7446 Op == AtomicExpr::AO__opencl_atomic_load ||
7447 Op == AtomicExpr::AO__hip_atomic_load ||
7448 Op == AtomicExpr::AO__opencl_atomic_store ||
7449 Op == AtomicExpr::AO__hip_atomic_store) &&
7452 << ((Op == AtomicExpr::AO__c11_atomic_load ||
7453 Op == AtomicExpr::AO__opencl_atomic_load ||
7454 Op == AtomicExpr::AO__hip_atomic_load)
7459 Diag(Ptr->
getExprLoc(), diag::err_atomic_builtin_bit_int_prohibit);
7475 assert(Fn &&
"builtin call without direct callee!");
7490bool Sema::BuiltinWasmRefNullExtern(
CallExpr *TheCall) {
7499bool Sema::BuiltinWasmRefNullFunc(
CallExpr *TheCall) {
7526Sema::SemaBuiltinAtomicOverloaded(
ExprResult TheCallResult) {
7534 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
7548 FirstArg = FirstArgResult.
get();
7549 TheCall->
setArg(0, FirstArg);
7561 Diag(DRE->
getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intptr)
7596#define BUILTIN_ROW(x) \
7597 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
7598 Builtin::BI##x##_8, Builtin::BI##x##_16 }
7600 static const unsigned BuiltinIndices[][5] = {
7626 case 1: SizeIndex = 0;
break;
7627 case 2: SizeIndex = 1;
break;
7628 case 4: SizeIndex = 2;
break;
7629 case 8: SizeIndex = 3;
break;
7630 case 16: SizeIndex = 4;
break;
7642 unsigned BuiltinIndex, NumFixed = 1;
7643 bool WarnAboutSemanticsChange =
false;
7644 switch (BuiltinID) {
7645 default: llvm_unreachable(
"Unknown overloaded atomic builtin!");
7646 case Builtin::BI__sync_fetch_and_add:
7647 case Builtin::BI__sync_fetch_and_add_1:
7648 case Builtin::BI__sync_fetch_and_add_2:
7649 case Builtin::BI__sync_fetch_and_add_4:
7650 case Builtin::BI__sync_fetch_and_add_8:
7651 case Builtin::BI__sync_fetch_and_add_16:
7655 case Builtin::BI__sync_fetch_and_sub:
7656 case Builtin::BI__sync_fetch_and_sub_1:
7657 case Builtin::BI__sync_fetch_and_sub_2:
7658 case Builtin::BI__sync_fetch_and_sub_4:
7659 case Builtin::BI__sync_fetch_and_sub_8:
7660 case Builtin::BI__sync_fetch_and_sub_16:
7664 case Builtin::BI__sync_fetch_and_or:
7665 case Builtin::BI__sync_fetch_and_or_1:
7666 case Builtin::BI__sync_fetch_and_or_2:
7667 case Builtin::BI__sync_fetch_and_or_4:
7668 case Builtin::BI__sync_fetch_and_or_8:
7669 case Builtin::BI__sync_fetch_and_or_16:
7673 case Builtin::BI__sync_fetch_and_and:
7674 case Builtin::BI__sync_fetch_and_and_1:
7675 case Builtin::BI__sync_fetch_and_and_2:
7676 case Builtin::BI__sync_fetch_and_and_4:
7677 case Builtin::BI__sync_fetch_and_and_8:
7678 case Builtin::BI__sync_fetch_and_and_16:
7682 case Builtin::BI__sync_fetch_and_xor:
7683 case Builtin::BI__sync_fetch_and_xor_1:
7684 case Builtin::BI__sync_fetch_and_xor_2:
7685 case Builtin::BI__sync_fetch_and_xor_4:
7686 case Builtin::BI__sync_fetch_and_xor_8:
7687 case Builtin::BI__sync_fetch_and_xor_16:
7691 case Builtin::BI__sync_fetch_and_nand:
7692 case Builtin::BI__sync_fetch_and_nand_1:
7693 case Builtin::BI__sync_fetch_and_nand_2:
7694 case Builtin::BI__sync_fetch_and_nand_4:
7695 case Builtin::BI__sync_fetch_and_nand_8:
7696 case Builtin::BI__sync_fetch_and_nand_16:
7698 WarnAboutSemanticsChange =
true;
7701 case Builtin::BI__sync_add_and_fetch:
7702 case Builtin::BI__sync_add_and_fetch_1:
7703 case Builtin::BI__sync_add_and_fetch_2:
7704 case Builtin::BI__sync_add_and_fetch_4:
7705 case Builtin::BI__sync_add_and_fetch_8:
7706 case Builtin::BI__sync_add_and_fetch_16:
7710 case Builtin::BI__sync_sub_and_fetch:
7711 case Builtin::BI__sync_sub_and_fetch_1:
7712 case Builtin::BI__sync_sub_and_fetch_2:
7713 case Builtin::BI__sync_sub_and_fetch_4:
7714 case Builtin::BI__sync_sub_and_fetch_8:
7715 case Builtin::BI__sync_sub_and_fetch_16:
7719 case Builtin::BI__sync_and_and_fetch:
7720 case Builtin::BI__sync_and_and_fetch_1:
7721 case Builtin::BI__sync_and_and_fetch_2:
7722 case Builtin::BI__sync_and_and_fetch_4:
7723 case Builtin::BI__sync_and_and_fetch_8:
7724 case Builtin::BI__sync_and_and_fetch_16:
7728 case Builtin::BI__sync_or_and_fetch:
7729 case Builtin::BI__sync_or_and_fetch_1:
7730 case Builtin::BI__sync_or_and_fetch_2:
7731 case Builtin::BI__sync_or_and_fetch_4:
7732 case Builtin::BI__sync_or_and_fetch_8:
7733 case Builtin::BI__sync_or_and_fetch_16:
7737 case Builtin::BI__sync_xor_and_fetch:
7738 case Builtin::BI__sync_xor_and_fetch_1:
7739 case Builtin::BI__sync_xor_and_fetch_2:
7740 case Builtin::BI__sync_xor_and_fetch_4:
7741 case Builtin::BI__sync_xor_and_fetch_8:
7742 case Builtin::BI__sync_xor_and_fetch_16:
7746 case Builtin::BI__sync_nand_and_fetch:
7747 case Builtin::BI__sync_nand_and_fetch_1:
7748 case Builtin::BI__sync_nand_and_fetch_2:
7749 case Builtin::BI__sync_nand_and_fetch_4:
7750 case Builtin::BI__sync_nand_and_fetch_8:
7751 case Builtin::BI__sync_nand_and_fetch_16:
7753 WarnAboutSemanticsChange =
true;
7756 case Builtin::BI__sync_val_compare_and_swap:
7757 case Builtin::BI__sync_val_compare_and_swap_1:
7758 case Builtin::BI__sync_val_compare_and_swap_2:
7759 case Builtin::BI__sync_val_compare_and_swap_4:
7760 case Builtin::BI__sync_val_compare_and_swap_8:
7761 case Builtin::BI__sync_val_compare_and_swap_16:
7766 case Builtin::BI__sync_bool_compare_and_swap:
7767 case Builtin::BI__sync_bool_compare_and_swap_1:
7768 case Builtin::BI__sync_bool_compare_and_swap_2:
7769 case Builtin::BI__sync_bool_compare_and_swap_4:
7770 case Builtin::BI__sync_bool_compare_and_swap_8:
7771 case Builtin::BI__sync_bool_compare_and_swap_16:
7777 case Builtin::BI__sync_lock_test_and_set:
7778 case Builtin::BI__sync_lock_test_and_set_1:
7779 case Builtin::BI__sync_lock_test_and_set_2:
7780 case Builtin::BI__sync_lock_test_and_set_4:
7781 case Builtin::BI__sync_lock_test_and_set_8:
7782 case Builtin::BI__sync_lock_test_and_set_16:
7786 case Builtin::BI__sync_lock_release:
7787 case Builtin::BI__sync_lock_release_1:
7788 case Builtin::BI__sync_lock_release_2:
7789 case Builtin::BI__sync_lock_release_4:
7790 case Builtin::BI__sync_lock_release_8:
7791 case Builtin::BI__sync_lock_release_16:
7797 case Builtin::BI__sync_swap:
7798 case Builtin::BI__sync_swap_1:
7799 case Builtin::BI__sync_swap_2:
7800 case Builtin::BI__sync_swap_4:
7801 case Builtin::BI__sync_swap_8:
7802 case Builtin::BI__sync_swap_16:
7810 Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
7811 << 0 << 1 + NumFixed << TheCall->
getNumArgs()
7812 <<
Callee->getSourceRange();
7816 Diag(TheCall->
getEndLoc(), diag::warn_atomic_implicit_seq_cst)
7817 <<
Callee->getSourceRange();
7819 if (WarnAboutSemanticsChange) {
7820 Diag(TheCall->
getEndLoc(), diag::warn_sync_fetch_and_nand_semantics_change)
7821 <<
Callee->getSourceRange();
7826 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
7829 if (NewBuiltinID == BuiltinID)
7830 NewBuiltinDecl = FDecl;
7836 assert(Res.getFoundDecl());
7837 NewBuiltinDecl = dyn_cast<FunctionDecl>(Res.getFoundDecl());
7838 if (!NewBuiltinDecl)
7845 for (
unsigned i = 0; i != NumFixed; ++i) {
7876 CK_BuiltinFnToFnPtr);
7888 if (BitIntValType && !llvm::isPowerOf2_64(BitIntValType->getNumBits())) {
7889 Diag(FirstArg->
getExprLoc(), diag::err_atomic_builtin_ext_int_size);
7893 return TheCallResult;
7908 assert((BuiltinID == Builtin::BI__builtin_nontemporal_store ||
7909 BuiltinID == Builtin::BI__builtin_nontemporal_load) &&
7910 "Unexpected nontemporal load/store builtin!");
7911 bool isStore = BuiltinID == Builtin::BI__builtin_nontemporal_store;
7912 unsigned numArgs = isStore ? 2 : 1;
7922 Expr *PointerArg = TheCall->
getArg(numArgs - 1);
7928 PointerArg = PointerArgResult.
get();
7929 TheCall->
setArg(numArgs - 1, PointerArg);
7933 Diag(DRE->
getBeginLoc(), diag::err_nontemporal_builtin_must_be_pointer)
7946 diag::err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector)
7953 return TheCallResult;
7965 return TheCallResult;
7972bool Sema::CheckObjCString(
Expr *Arg) {
7976 if (!Literal || !
Literal->isOrdinary()) {
7977 Diag(Arg->
getBeginLoc(), diag::err_cfstring_literal_not_string_constant)
7982 if (
Literal->containsNonAsciiOrNull()) {
7983 StringRef String =
Literal->getString();
7984 unsigned NumBytes = String.size();
7986 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
7987 llvm::UTF16 *ToPtr = &ToBuf[0];
7989 llvm::ConversionResult
Result =
7990 llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
7991 ToPtr + NumBytes, llvm::strictConversion);
7993 if (
Result != llvm::conversionOK)
8004 auto *
Literal = dyn_cast<StringLiteral>(Arg);
8006 if (
auto *ObjcLiteral = dyn_cast<ObjCStringLiteral>(Arg)) {
8007 Literal = ObjcLiteral->getString();
8011 if (!Literal || (!
Literal->isOrdinary() && !
Literal->isUTF8())) {
8029 bool IsX64 = TT.getArch() == llvm::Triple::x86_64;
8030 bool IsAArch64 = (TT.getArch() == llvm::Triple::aarch64 ||
8031 TT.getArch() == llvm::Triple::aarch64_32);
8032 bool IsWindows = TT.isOSWindows();
8033 bool IsMSVAStart = BuiltinID == Builtin::BI__builtin_ms_va_start;
8034 if (IsX64 || IsAArch64) {
8042 diag::err_ms_va_start_used_in_sysv_function);
8051 diag::err_va_start_used_in_wrong_abi_function)
8066 bool IsVariadic =
false;
8069 if (
auto *
Block = dyn_cast<BlockDecl>(Caller)) {
8070 IsVariadic =
Block->isVariadic();
8071 Params =
Block->parameters();
8072 }
else if (
auto *FD = dyn_cast<FunctionDecl>(Caller)) {
8075 }
else if (
auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {
8076 IsVariadic = MD->isVariadic();
8078 Params = MD->parameters();
8079 }
else if (isa<CapturedDecl>(Caller)) {
8095 *LastParam = Params.empty() ? nullptr : Params.back();
8103bool Sema::SemaBuiltinVAStart(
unsigned BuiltinID,
CallExpr *TheCall) {
8128 bool SecondArgIsLastNamedArgument =
false;
8130 if (std::optional<llvm::APSInt> Val =
8139 bool IsCRegister =
false;
8141 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
8142 if (
const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
8143 SecondArgIsLastNamedArgument = PV == LastParam;
8145 Type = PV->getType();
8146 ParamLoc = PV->getLocation();
8152 if (!SecondArgIsLastNamedArgument)
8154 diag::warn_second_arg_of_va_start_not_last_named_param);
8159 if (!Context.isPromotableIntegerType(Type))
8161 if (!Type->isEnumeralType())
8163 const EnumDecl *ED = Type->castAs<EnumType>()->getDecl();
8165 Context.typesAreCompatible(ED->getPromotionType(), Type));
8167 unsigned Reason = 0;
8169 else if (IsCRegister) Reason = 2;
8170 Diag(Arg->
getBeginLoc(), diag::warn_va_start_type_is_undefined) << Reason;
8171 Diag(ParamLoc, diag::note_parameter_type) <<
Type;
8177bool Sema::SemaBuiltinVAStartARMMicrosoft(
CallExpr *Call) {
8178 auto IsSuitablyTypedFormatArgument = [
this](
const Expr *Arg) ->
bool {
8198 if (
Call->getNumArgs() < 3)
8200 diag::err_typecheck_call_too_few_args_at_least)
8201 << 0 << 3 <<
Call->getNumArgs();
8213 const Expr *Arg1 =
Call->getArg(1)->IgnoreParens();
8216 const Expr *Arg2 =
Call->getArg(2)->IgnoreParens();
8221 if (!Arg1Ty->
isPointerType() || !IsSuitablyTypedFormatArgument(Arg1))
8223 << Arg1->
getType() << ConstCharPtrTy << 1
8226 << 2 << Arg1->
getType() << ConstCharPtrTy;
8231 << Arg2->
getType() << SizeTy << 1
8234 << 3 << Arg2->
getType() << SizeTy;
8241bool Sema::SemaBuiltinUnorderedCompare(
CallExpr *TheCall) {
8268 diag::err_typecheck_call_invalid_ordered_compare)
8280bool Sema::SemaBuiltinFPClassification(
CallExpr *TheCall,
unsigned NumArgs) {
8285 unsigned FPArgNo = (NumArgs == 2) ? 0 : NumArgs - 1;
8289 for (
unsigned i = 0; i < FPArgNo; ++i) {
8314 TheCall->
setArg(FPArgNo, OrigArg);
8319 diag::err_typecheck_call_invalid_unary_fp)
8325 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, llvm::fcAllFlags))
8332bool Sema::SemaBuiltinComplex(
CallExpr *TheCall) {
8336 bool Dependent =
false;
8337 for (
unsigned I = 0; I != 2; ++I) {
8340 if (T->isDependentType()) {
8347 if (!T->isRealFloatingType()) {
8348 return Diag(Arg->
getBeginLoc(), diag::err_typecheck_call_requires_real_fp)
8367 diag::err_typecheck_call_different_arg_types)
8393bool Sema::SemaBuiltinVSX(
CallExpr *TheCall) {
8394 unsigned ExpectedNumArgs = 3;
8401 diag::err_vsx_builtin_nonconstant_argument)
8413 return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector)
8421 return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)
8440 diag::err_typecheck_call_too_few_args_at_least)
8448 unsigned numElements = 0;
8463 unsigned numResElements = TheCall->
getNumArgs() - 2;
8472 diag::err_vec_builtin_incompatible_vector)
8478 diag::err_vec_builtin_incompatible_vector)
8482 }
else if (numElements != numResElements) {
8489 for (
unsigned i = 2; i < TheCall->
getNumArgs(); i++) {
8494 std::optional<llvm::APSInt>
Result;
8497 diag::err_shufflevector_nonconstant_argument)
8504 if (
Result->getActiveBits() > 64 ||
8505 Result->getZExtValue() >= numElements * 2)
8507 diag::err_shufflevector_argument_too_large)
8513 for (
unsigned i = 0, e = TheCall->
getNumArgs(); i != e; i++) {
8514 exprs.push_back(TheCall->
getArg(i));
8515 TheCall->
setArg(i,
nullptr);
8534 diag::err_convertvector_non_vector)
8538 diag::err_convertvector_non_vector_type));
8543 if (SrcElts != DstElts)
8545 diag::err_convertvector_incompatible_vector)
8556bool Sema::SemaBuiltinPrefetch(
CallExpr *TheCall) {
8561 diag::err_typecheck_call_too_many_args_at_most)
8566 for (
unsigned i = 1; i != NumArgs; ++i)
8567 if (SemaBuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
8574bool Sema::SemaBuiltinArithmeticFence(
CallExpr *TheCall) {
8576 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_target_unsupported)
8586 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_expect_flt_or_vector)
8599bool Sema::SemaBuiltinAssume(
CallExpr *TheCall) {
8614bool Sema::SemaBuiltinAllocaWithAlign(
CallExpr *TheCall) {
8620 if (
const auto *UE =
8622 if (UE->getKind() == UETT_AlignOf ||
8623 UE->getKind() == UETT_PreferredAlignOf)
8629 if (!
Result.isPowerOf2())
8630 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
8637 if (
Result > std::numeric_limits<int32_t>::max())
8647bool Sema::SemaBuiltinAssumeAligned(
CallExpr *TheCall) {
8660 TheCall->
setArg(0, FirstArgResult.
get());
8669 if (SemaBuiltinConstantArg(TheCall, 1,
Result))
8672 if (!
Result.isPowerOf2())
8673 return Diag(TheCall->
getBeginLoc(), diag::err_alignment_not_power_of_two)
8685 TheCall->
setArg(2, ThirdArg);
8691bool Sema::SemaBuiltinOSLogFormat(
CallExpr *TheCall) {
8692 unsigned BuiltinID =
8694 bool IsSizeCall = BuiltinID == Builtin::BI__builtin_os_log_format_buffer_size;
8697 unsigned NumRequiredArgs = IsSizeCall ? 1 : 2;
8698 if (NumArgs < NumRequiredArgs) {
8699 return Diag(TheCall->
getEndLoc(), diag::err_typecheck_call_too_few_args)
8700 << 0 << NumRequiredArgs << NumArgs
8703 if (NumArgs >= NumRequiredArgs + 0x100) {
8705 diag::err_typecheck_call_too_many_args_at_most)
8706 << 0 << (NumRequiredArgs + 0xff) << NumArgs
8717 if (Arg.isInvalid())
8719 TheCall->
setArg(i, Arg.get());
8724 unsigned FormatIdx = i;
8734 unsigned FirstDataArg = i;
8735 while (i < NumArgs) {
8753 llvm::SmallBitVector CheckedVarArgs(NumArgs,
false);
8755 bool Success = CheckFormatArguments(
8773bool Sema::SemaBuiltinConstantArg(
CallExpr *TheCall,
int ArgNum,
8781 std::optional<llvm::APSInt> R;
8783 return Diag(TheCall->
getBeginLoc(), diag::err_constant_integer_arg_type)
8791bool Sema::SemaBuiltinConstantArgRange(
CallExpr *TheCall,
int ArgNum,
8792 int Low,
int High,
bool RangeIsError) {
8803 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
8806 if (
Result.getSExtValue() < Low ||
Result.getSExtValue() > High) {
8814 PDiag(diag::warn_argument_invalid_range)
8824bool Sema::SemaBuiltinConstantArgMultiple(
CallExpr *TheCall,
int ArgNum,
8834 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
8837 if (
Result.getSExtValue() % Num != 0)
8846bool Sema::SemaBuiltinConstantArgPower2(
CallExpr *TheCall,
int ArgNum) {
8855 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
8863 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_power_of_2)
8868 if (
Value.isNegative())
8879 if ((
Value & 0xFF) != 0)
8892bool Sema::SemaBuiltinConstantArgShiftedByte(
CallExpr *TheCall,
int ArgNum,
8902 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
8907 Result.setIsUnsigned(
true);
8912 return Diag(TheCall->
getBeginLoc(), diag::err_argument_not_shifted_byte)
8921bool Sema::SemaBuiltinConstantArgShiftedByteOrXXFF(
CallExpr *TheCall,
8932 if (SemaBuiltinConstantArg(TheCall, ArgNum,
Result))
8937 Result.setIsUnsigned(
true);
8945 diag::err_argument_not_shifted_byte_or_xxff)
8950bool Sema::SemaBuiltinARMMemoryTaggingCall(
unsigned BuiltinID,
CallExpr *TheCall) {
8951 if (BuiltinID == AArch64::BI__builtin_arm_irg) {
8962 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
8971 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
8975 TheCall->
setType(FirstArgType);
8979 if (BuiltinID == AArch64::BI__builtin_arm_addg) {
8989 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
8994 TheCall->
setType(FirstArgType);
8997 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
9000 if (BuiltinID == AArch64::BI__builtin_arm_gmi) {
9011 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
9016 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_integer)
9022 if (BuiltinID == AArch64::BI__builtin_arm_ldg ||
9023 BuiltinID == AArch64::BI__builtin_arm_stg) {
9033 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_must_be_pointer)
9038 if (BuiltinID == AArch64::BI__builtin_arm_ldg)
9039 TheCall->
setType(FirstArgType);
9043 if (BuiltinID == AArch64::BI__builtin_arm_subp) {
9056 auto isNull = [&] (
Expr *E) ->
bool {
9062 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
9066 return Diag(TheCall->
getBeginLoc(), diag::err_memtag_arg_null_or_pointer)
9077 return Diag(TheCall->
getBeginLoc(), diag::err_typecheck_sub_ptr_compatible)
9099 assert(
false &&
"Unhandled ARM MTE intrinsic");
9105bool Sema::SemaBuiltinARMSpecialReg(
unsigned BuiltinID,
CallExpr *TheCall,
9106 int ArgNum,
unsigned ExpectedFieldNum,
9108 bool IsARMBuiltin = BuiltinID == ARM::BI__builtin_arm_rsr64 ||
9109 BuiltinID == ARM::BI__builtin_arm_wsr64 ||
9110 BuiltinID == ARM::BI__builtin_arm_rsr ||
9111 BuiltinID == ARM::BI__builtin_arm_rsrp ||
9112 BuiltinID == ARM::BI__builtin_arm_wsr ||
9113 BuiltinID == ARM::BI__builtin_arm_wsrp;
9114 bool IsAArch64Builtin = BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
9115 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
9116 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
9117 BuiltinID == AArch64::BI__builtin_arm_wsr128 ||
9118 BuiltinID == AArch64::BI__builtin_arm_rsr ||
9119 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
9120 BuiltinID == AArch64::BI__builtin_arm_wsr ||
9121 BuiltinID == AArch64::BI__builtin_arm_wsrp;
9122 assert((IsARMBuiltin || IsAArch64Builtin) &&
"Unexpected ARM builtin.");
9131 return Diag(TheCall->
getBeginLoc(), diag::err_expr_not_string_literal)
9137 Reg.split(Fields,
":");
9139 if (Fields.size() != ExpectedFieldNum && !(AllowName && Fields.size() == 1))
9147 if (Fields.size() > 1) {
9148 bool FiveFields = Fields.size() == 5;
9150 bool ValidString =
true;
9152 ValidString &= Fields[0].starts_with_insensitive(
"cp") ||
9153 Fields[0].starts_with_insensitive(
"p");
9155 Fields[0] = Fields[0].drop_front(
9156 Fields[0].starts_with_insensitive(
"cp") ? 2 : 1);
9158 ValidString &= Fields[2].starts_with_insensitive(
"c");
9160 Fields[2] = Fields[2].drop_front(1);
9163 ValidString &= Fields[3].starts_with_insensitive(
"c");
9165 Fields[3] = Fields[3].drop_front(1);
9171 Ranges.append({IsAArch64Builtin ? 1 : 15, 7, 15, 15, 7});
9173 Ranges.append({15, 7, 15});
9175 for (
unsigned i=0; i<Fields.size(); ++i) {
9177 ValidString &= !Fields[i].getAsInteger(10, IntField);
9178 ValidString &= (IntField >= 0 && IntField <= Ranges[i]);
9184 }
else if (IsAArch64Builtin && Fields.size() == 1) {
9192 if (BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
9193 BuiltinID == AArch64::BI__builtin_arm_wsr128)
9198 auto MaxLimit = llvm::StringSwitch<std::optional<unsigned>>(Reg)
9199 .CaseLower(
"spsel", 15)
9200 .CaseLower(
"daifclr", 15)
9201 .CaseLower(
"daifset", 15)
9202 .CaseLower(
"pan", 15)
9203 .CaseLower(
"uao", 15)
9204 .CaseLower(
"dit", 15)
9205 .CaseLower(
"ssbs", 15)
9206 .CaseLower(
"tco", 15)
9207 .CaseLower(
"allint", 1)
9209 .Default(std::nullopt);
9229 return SemaBuiltinConstantArgRange(TheCall, 1, 0, *MaxLimit);
9239bool Sema::SemaBuiltinPPCMMACall(
CallExpr *TheCall,
unsigned BuiltinID,
9240 const char *TypeStr) {
9242 assert((TypeStr[0] !=
'\0') &&
9243 "Invalid types in PPC MMA builtin declaration");
9246 unsigned ArgNum = 0;
9253 while (*TypeStr !=
'\0') {
9277 diag::err_typecheck_convert_incompatible)
9284 SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, Mask,
true))
9294 while (*TypeStr !=
'\0') {
9307bool Sema::SemaBuiltinLongjmp(
CallExpr *TheCall) {
9309 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_unsupported)
9316 if (SemaBuiltinConstantArg(TheCall, 1,
Result))
9320 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_longjmp_invalid_val)
9328bool Sema::SemaBuiltinSetjmp(
CallExpr *TheCall) {
9330 return Diag(TheCall->
getBeginLoc(), diag::err_builtin_setjmp_unsupported)
9337class UncoveredArgHandler {
9338 enum {
Unknown = -1, AllCovered = -2 };
9340 signed FirstUncoveredArg =
Unknown;
9344 UncoveredArgHandler() =
default;
9346 bool hasUncoveredArg()
const {
9347 return (FirstUncoveredArg >= 0);
9350 unsigned getUncoveredArg()
const {
9351 assert(hasUncoveredArg() &&
"no uncovered argument");
9352 return FirstUncoveredArg;
9355 void setAllCovered() {
9358 DiagnosticExprs.clear();
9359 FirstUncoveredArg = AllCovered;
9362 void Update(
signed NewFirstUncoveredArg,
const Expr *StrExpr) {
9363 assert(NewFirstUncoveredArg >= 0 &&
"Outside range");
9366 if (FirstUncoveredArg == AllCovered)
9371 if (NewFirstUncoveredArg == FirstUncoveredArg)
9372 DiagnosticExprs.push_back(StrExpr);
9373 else if (NewFirstUncoveredArg > FirstUncoveredArg) {
9374 DiagnosticExprs.clear();
9375 DiagnosticExprs.push_back(StrExpr);
9376 FirstUncoveredArg = NewFirstUncoveredArg;
9380 void Diagnose(
Sema &S,
bool IsFunctionCall,
const Expr *ArgExpr);
9383enum StringLiteralCheckType {
9385 SLCT_UncheckedLiteral,
9393 bool AddendIsRight) {
9394 unsigned BitWidth =
Offset.getBitWidth();
9395 unsigned AddendBitWidth = Addend.getBitWidth();
9397 if (Addend.isUnsigned()) {
9398 Addend = Addend.zext(++AddendBitWidth);
9399 Addend.setIsSigned(
true);
9402 if (AddendBitWidth > BitWidth) {
9404 BitWidth = AddendBitWidth;
9405 }
else if (BitWidth > AddendBitWidth) {
9406 Addend = Addend.sext(BitWidth);
9410 llvm::APSInt ResOffset =
Offset;
9411 if (BinOpKind == BO_Add)
9412 ResOffset =
Offset.sadd_ov(Addend, Ov);
9414 assert(AddendIsRight && BinOpKind == BO_Sub &&
9415 "operator must be add or sub with addend on the right");
9416 ResOffset =
Offset.ssub_ov(Addend, Ov);
9422 assert(BitWidth <= std::numeric_limits<unsigned>::max() / 2 &&
9423 "index (intermediate) result too big");
9437class FormatStringLiteral {
9445 StringRef getString()
const {
9449 unsigned getByteLength()
const {
9460 bool isAscii()
const {
return FExpr->
isOrdinary(); }
9461 bool isWide()
const {
return FExpr->
isWide(); }
9462 bool isUTF8()
const {
return FExpr->
isUTF8(); }
9463 bool isUTF16()
const {
return FExpr->
isUTF16(); }
9464 bool isUTF32()
const {
return FExpr->
isUTF32(); }
9465 bool isPascal()
const {
return FExpr->
isPascal(); }
9469 const TargetInfo &Target,
unsigned *StartToken =
nullptr,
9470 unsigned *StartTokenByteOffset =
nullptr)
const {
9472 StartToken, StartTokenByteOffset);
9485 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
9489 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
9490 bool IgnoreStringsWithoutSpecifiers);
9499static StringLiteralCheckType
9504 llvm::SmallBitVector &CheckedVarArgs,
9505 UncoveredArgHandler &UncoveredArg, llvm::APSInt
Offset,
9506 bool IgnoreStringsWithoutSpecifiers =
false) {
9508 return SLCT_NotALiteral;
9510 assert(
Offset.isSigned() &&
"invalid offset");
9513 return SLCT_NotALiteral;
9522 return SLCT_UncheckedLiteral;
9525 case Stmt::InitListExprClass:
9529 Type, CallType,
false,
9530 CheckedVarArgs, UncoveredArg,
Offset,
9531 IgnoreStringsWithoutSpecifiers);
9533 return SLCT_NotALiteral;
9534 case Stmt::BinaryConditionalOperatorClass:
9535 case Stmt::ConditionalOperatorClass: {
9544 bool CheckLeft =
true, CheckRight =
true;
9559 StringLiteralCheckType Left;
9561 Left = SLCT_UncheckedLiteral;
9564 firstDataArg,
Type, CallType, InFunctionCall,
9565 CheckedVarArgs, UncoveredArg,
Offset,
9566 IgnoreStringsWithoutSpecifiers);
9567 if (Left == SLCT_NotALiteral || !CheckRight) {
9573 S,
C->getFalseExpr(), Args, APK, format_idx, firstDataArg,
Type,
9574 CallType, InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
9575 IgnoreStringsWithoutSpecifiers);
9577 return (CheckLeft && Left < Right) ? Left : Right;
9580 case Stmt::ImplicitCastExprClass:
9584 case Stmt::OpaqueValueExprClass:
9585 if (
const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) {
9589 return SLCT_NotALiteral;
9591 case Stmt::PredefinedExprClass:
9595 return SLCT_UncheckedLiteral;
9597 case Stmt::DeclRefExprClass: {
9603 bool isConstant =
false;
9607 isConstant = AT->getElementType().isConstant(S.
Context);
9609 isConstant = T.isConstant(S.
Context) &&
9610 PT->getPointeeType().isConstant(S.
Context);
9611 }
else if (T->isObjCObjectPointerType()) {
9614 isConstant = T.isConstant(S.
Context);
9618 if (
const Expr *Init = VD->getAnyInitializer()) {
9620 if (
const InitListExpr *InitList = dyn_cast<InitListExpr>(Init)) {
9621 if (InitList->isStringLiteralInit())
9622 Init = InitList->getInit(0)->IgnoreParenImpCasts();
9625 S, Init, Args, APK, format_idx, firstDataArg,
Type, CallType,
9626 false, CheckedVarArgs, UncoveredArg,
Offset);
9667 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
9668 if (
const auto *D = dyn_cast<Decl>(PV->getDeclContext())) {
9670 bool IsCXXMember =
false;
9671 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D))
9672 IsCXXMember = MD->isInstance();
9674 bool IsVariadic =
false;
9677 else if (
const auto *BD = dyn_cast<BlockDecl>(D))
9678 IsVariadic = BD->isVariadic();
9679 else if (
const auto *OMD = dyn_cast<ObjCMethodDecl>(D))
9680 IsVariadic = OMD->isVariadic();
9687 if (PV->getFunctionScopeIndex() == CallerFSI.
FormatIdx &&
9700 return SLCT_UncheckedLiteral;
9709 return SLCT_NotALiteral;
9712 case Stmt::CallExprClass:
9713 case Stmt::CXXMemberCallExprClass: {
9717 StringLiteralCheckType CommonResult;
9718 for (
const auto *FA : ND->specific_attrs<FormatArgAttr>()) {
9719 const Expr *Arg = CE->
getArg(FA->getFormatIdx().getASTIndex());
9721 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
9722 InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
9723 IgnoreStringsWithoutSpecifiers);
9730 return CommonResult;
9732 if (
const auto *FD = dyn_cast<FunctionDecl>(ND)) {
9734 if (BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||
9735 BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString) {
9738 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
9739 InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
9740 IgnoreStringsWithoutSpecifiers);
9746 Type, CallType,
false,
9747 CheckedVarArgs, UncoveredArg,
Offset,
9748 IgnoreStringsWithoutSpecifiers);
9749 return SLCT_NotALiteral;
9751 case Stmt::ObjCMessageExprClass: {
9753 if (
const auto *MD = ME->getMethodDecl()) {
9754 if (
const auto *FA = MD->getAttr<FormatArgAttr>()) {
9763 if (MD->isInstanceMethod() && (IFace = MD->getClassInterface()) &&
9765 MD->getSelector().isKeywordSelector(
9766 {
"localizedStringForKey",
"value",
"table"})) {
9767 IgnoreStringsWithoutSpecifiers =
true;
9770 const Expr *Arg = ME->getArg(FA->getFormatIdx().getASTIndex());
9772 S, Arg, Args, APK, format_idx, firstDataArg,
Type, CallType,
9773 InFunctionCall, CheckedVarArgs, UncoveredArg,
Offset,
9774 IgnoreStringsWithoutSpecifiers);
9778 return SLCT_NotALiteral;
9780 case Stmt::ObjCStringLiteralClass:
9781 case Stmt::StringLiteralClass: {
9793 return SLCT_NotALiteral;
9795 FormatStringLiteral FStr(StrE,
Offset.sextOrTrunc(64).getSExtValue());
9797 InFunctionCall, CallType, CheckedVarArgs, UncoveredArg,
9798 IgnoreStringsWithoutSpecifiers);
9799 return SLCT_CheckedLiteral;
9802 return SLCT_NotALiteral;
9804 case Stmt::BinaryOperatorClass: {
9816 if (LIsInt != RIsInt) {
9820 if (BinOpKind == BO_Add) {
9833 return SLCT_NotALiteral;
9835 case Stmt::UnaryOperatorClass: {
9837 auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->
getSubExpr());
9838 if (UnaOp->
getOpcode() == UO_AddrOf && ASE) {
9840 if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.
Context,
9850 return SLCT_NotALiteral;
9854 return SLCT_NotALiteral;
9865 const auto *LVE =
Result.Val.getLValueBase().dyn_cast<
const Expr *>();
9866 if (isa_and_nonnull<StringLiteral>(LVE))
9873 return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
9879 .Cases(
"kprintf",
"cmn_err",
"vcmn_err",
"zcmn_err",
FST_Kprintf)
9889bool Sema::CheckFormatArguments(
const FormatAttr *Format,
9893 llvm::SmallBitVector &CheckedVarArgs) {
9894 FormatStringInfo FSI;
9897 return CheckFormatArguments(Args, FSI.ArgPassingKind, FSI.FormatIdx,
9899 CallType, Loc, Range, CheckedVarArgs);
9905 unsigned format_idx,
unsigned firstDataArg,
9906 FormatStringType
Type,
9909 llvm::SmallBitVector &CheckedVarArgs) {
9911 if (format_idx >= Args.size()) {
9912 Diag(Loc, diag::warn_missing_format_string) << Range;
9916 const Expr *OrigFormatExpr = Args[format_idx]->IgnoreParenCasts();
9930 UncoveredArgHandler UncoveredArg;
9932 *
this, OrigFormatExpr, Args, APK, format_idx, firstDataArg,
Type,
9934 true, CheckedVarArgs, UncoveredArg,
9935 llvm::APSInt(64,
false) = 0);
9938 if (UncoveredArg.hasUncoveredArg()) {
9939 unsigned ArgIdx = UncoveredArg.getUncoveredArg() + firstDataArg;
9940 assert(ArgIdx < Args.size() &&
"ArgIdx outside bounds");
9941 UncoveredArg.Diagnose(*
this,
true, Args[ArgIdx]);
9944 if (CT != SLCT_NotALiteral)
9946 return CT == SLCT_CheckedLiteral;
9963 if (Args.size() == firstDataArg) {
9964 Diag(FormatLoc, diag::warn_format_nonliteral_noargs)
9972 Diag(FormatLoc, diag::note_format_security_fixit)
9976 Diag(FormatLoc, diag::note_format_security_fixit)
9981 Diag(FormatLoc, diag::warn_format_nonliteral)
9992 const FormatStringLiteral *FExpr;
9993 const Expr *OrigFormatExpr;
9995 const unsigned FirstDataArg;
9996 const unsigned NumDataArgs;
10000 unsigned FormatIdx;
10001 llvm::SmallBitVector CoveredArgs;
10002 bool usesPositionalArgs =
false;
10003 bool atFirstArg =
true;
10004 bool inFunctionCall;
10006 llvm::SmallBitVector &CheckedVarArgs;
10007 UncoveredArgHandler &UncoveredArg;
10010 CheckFormatHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
10011 const Expr *origFormatExpr,
10013 unsigned numDataArgs,
const char *beg,
10017 llvm::SmallBitVector &CheckedVarArgs,
10018 UncoveredArgHandler &UncoveredArg)
10019 : S(
s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(type),
10020 FirstDataArg(firstDataArg), NumDataArgs(numDataArgs), Beg(beg),
10021 ArgPassingKind(APK), Args(Args), FormatIdx(formatIdx),
10022 inFunctionCall(inFunctionCall), CallType(callType),
10023 CheckedVarArgs(CheckedVarArgs), UncoveredArg(UncoveredArg) {
10024 CoveredArgs.resize(numDataArgs);
10025 CoveredArgs.reset();
10028 void DoneProcessing();
10030 void HandleIncompleteSpecifier(
const char *startSpecifier,
10031 unsigned specifierLen)
override;
10033 void HandleInvalidLengthModifier(
10036 const char *startSpecifier,
unsigned specifierLen,
10039 void HandleNonStandardLengthModifier(
10041 const char *startSpecifier,
unsigned specifierLen);
10043 void HandleNonStandardConversionSpecifier(
10045 const char *startSpecifier,
unsigned specifierLen);
10047 void HandlePosition(
const char *startPos,
unsigned posLen)
override;
10049 void HandleInvalidPosition(
const char *startSpecifier,
10050 unsigned specifierLen,
10053 void HandleZeroPosition(
const char *startPos,
unsigned posLen)
override;
10055 void HandleNullChar(
const char *nullCharacter)
override;
10057 template <
typename Range>
10059 EmitFormatDiagnostic(
Sema &S,
bool inFunctionCall,
const Expr *ArgumentExpr,
10061 bool IsStringLocation, Range StringRange,
10065 bool HandleInvalidConversionSpecifier(
unsigned argIndex,
SourceLocation Loc,
10066 const char *startSpec,
10067 unsigned specifierLen,
10068 const char *csStart,
unsigned csLen);
10071 const char *startSpec,
10072 unsigned specifierLen);
10076 unsigned specifierLen);
10079 const Expr *getDataArg(
unsigned i)
const;
10083 const char *startSpecifier,
unsigned specifierLen,
10084 unsigned argIndex);
10086 template <
typename Range>
10088 bool IsStringLocation, Range StringRange,
10094SourceRange CheckFormatHandler::getFormatStringRange() {
10099getSpecifierRange(
const char *startSpecifier,
unsigned specifierLen) {
10101 SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
10104 End = End.getLocWithOffset(1);
10109SourceLocation CheckFormatHandler::getLocationOfByte(
const char *x) {
10114void CheckFormatHandler::HandleIncompleteSpecifier(
const char *startSpecifier,
10115 unsigned specifierLen){
10116 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_incomplete_specifier),
10117 getLocationOfByte(startSpecifier),
10119 getSpecifierRange(startSpecifier, specifierLen));
10122void CheckFormatHandler::HandleInvalidLengthModifier(
10125 const char *startSpecifier,
unsigned specifierLen,
unsigned DiagID) {
10126 using namespace analyze_format_string;
10128 const LengthModifier &LM = FS.getLengthModifier();
10129 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
10132 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
10134 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
10135 getLocationOfByte(LM.getStart()),
10137 getSpecifierRange(startSpecifier, specifierLen));
10139 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
10140 << FixedLM->toString()
10145 if (DiagID == diag::warn_format_nonsensical_length)
10148 EmitFormatDiagnostic(S.
PDiag(DiagID) << LM.toString() << CS.
toString(),
10149 getLocationOfByte(LM.getStart()),
10151 getSpecifierRange(startSpecifier, specifierLen),
10156void CheckFormatHandler::HandleNonStandardLengthModifier(
10158 const char *startSpecifier,
unsigned specifierLen) {
10159 using namespace analyze_format_string;
10161 const LengthModifier &LM = FS.getLengthModifier();
10162 CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength());
10165 std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
10167 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
10168 << LM.toString() << 0,
10169 getLocationOfByte(LM.getStart()),
10171 getSpecifierRange(startSpecifier, specifierLen));
10173 S.
Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
10174 << FixedLM->toString()
10178 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
10179 << LM.toString() << 0,
10180 getLocationOfByte(LM.getStart()),
10182 getSpecifierRange(startSpecifier, specifierLen));
10186void CheckFormatHandler::HandleNonStandardConversionSpecifier(
10188 const char *startSpecifier,
unsigned specifierLen) {
10189 using namespace analyze_format_string;
10194 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
10198 getSpecifierRange(startSpecifier, specifierLen));
10201 S.
Diag(getLocationOfByte(CS.
getStart()), diag::note_format_fix_specifier)
10202 << FixedCS->toString()
10205 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard)
10209 getSpecifierRange(startSpecifier, specifierLen));
10213void CheckFormatHandler::HandlePosition(
const char *startPos,
10215 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_non_standard_positional_arg),
10216 getLocationOfByte(startPos),
10218 getSpecifierRange(startPos, posLen));
10221void CheckFormatHandler::HandleInvalidPosition(
10222 const char *startSpecifier,
unsigned specifierLen,
10224 EmitFormatDiagnostic(
10225 S.
PDiag(diag::warn_format_invalid_positional_specifier) << (
unsigned)p,
10226 getLocationOfByte(startSpecifier),
true,
10227 getSpecifierRange(startSpecifier, specifierLen));
10230void CheckFormatHandler::HandleZeroPosition(
const char *startPos,
10232 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_zero_positional_specifier),
10233 getLocationOfByte(startPos),
10235 getSpecifierRange(startPos, posLen));
10238void CheckFormatHandler::HandleNullChar(
const char *nullCharacter) {
10239 if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
10241 EmitFormatDiagnostic(
10242 S.
PDiag(diag::warn_printf_format_string_contains_null_char),
10243 getLocationOfByte(nullCharacter),
true,
10244 getFormatStringRange());
10250const Expr *CheckFormatHandler::getDataArg(
unsigned i)
const {
10251 return Args[FirstDataArg + i];
10254void CheckFormatHandler::DoneProcessing() {
10259 CoveredArgs.flip();
10260 signed notCoveredArg = CoveredArgs.find_first();
10261 if (notCoveredArg >= 0) {
10262 assert((
unsigned)notCoveredArg < NumDataArgs);
10263 UncoveredArg.Update(notCoveredArg, OrigFormatExpr);
10265 UncoveredArg.setAllCovered();
10270void UncoveredArgHandler::Diagnose(
Sema &S,
bool IsFunctionCall,
10271 const Expr *ArgExpr) {
10272 assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
10284 for (
auto E : DiagnosticExprs)
10287 CheckFormatHandler::EmitFormatDiagnostic(
10288 S, IsFunctionCall, DiagnosticExprs[0],
10294CheckFormatHandler::HandleInvalidConversionSpecifier(
unsigned argIndex,
10296 const char *startSpec,
10297 unsigned specifierLen,
10298 const char *csStart,
10300 bool keepGoing =
true;
10301 if (argIndex < NumDataArgs) {
10304 CoveredArgs.set(argIndex);
10320 std::string CodePointStr;
10321 if (!llvm::sys::locale::isPrint(*csStart)) {
10322 llvm::UTF32 CodePoint;
10323 const llvm::UTF8 **B =
reinterpret_cast<const llvm::UTF8 **
>(&csStart);
10324 const llvm::UTF8 *E =
10325 reinterpret_cast<const llvm::UTF8 *
>(csStart + csLen);
10326 llvm::ConversionResult
Result =
10327 llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
10329 if (
Result != llvm::conversionOK) {
10330 unsigned char FirstChar = *csStart;
10331 CodePoint = (llvm::UTF32)FirstChar;
10334 llvm::raw_string_ostream OS(CodePointStr);
10335 if (CodePoint < 256)
10336 OS <<
"\\x" << llvm::format(
"%02x", CodePoint);
10337 else if (CodePoint <= 0xFFFF)
10338 OS <<
"\\u" << llvm::format(
"%04x", CodePoint);
10340 OS <<
"\\U" << llvm::format(
"%08x", CodePoint);
10342 Specifier = CodePointStr;
10345 EmitFormatDiagnostic(
10346 S.
PDiag(diag::warn_format_invalid_conversion) << Specifier, Loc,
10347 true, getSpecifierRange(startSpec, specifierLen));
10353CheckFormatHandler::HandlePositionalNonpositionalArgs(
SourceLocation Loc,
10354 const char *startSpec,
10355 unsigned specifierLen) {
10356 EmitFormatDiagnostic(
10357 S.
PDiag(diag::warn_format_mix_positional_nonpositional_args),
10358 Loc,
true, getSpecifierRange(startSpec, specifierLen));
10362CheckFormatHandler::CheckNumArgs(
10365 const char *startSpecifier,
unsigned specifierLen,
unsigned argIndex) {
10367 if (argIndex >= NumDataArgs) {
10369 ? (S.
PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
10370 << (argIndex+1) << NumDataArgs)
10371 : S.
PDiag(diag::warn_printf_insufficient_data_args);
10372 EmitFormatDiagnostic(
10373 PDiag, getLocationOfByte(CS.
getStart()),
true,
10374 getSpecifierRange(startSpecifier, specifierLen));
10378 UncoveredArg.setAllCovered();
10384template<
typename Range>
10387 bool IsStringLocation,
10390 EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
10391 Loc, IsStringLocation, StringRange, FixIt);
10421template <
typename Range>
10422void CheckFormatHandler::EmitFormatDiagnostic(
10423 Sema &S,
bool InFunctionCall,
const Expr *ArgumentExpr,
10426 if (InFunctionCall) {
10431 S.
Diag(IsStringLocation ? ArgumentExpr->
getExprLoc() : Loc, PDiag)
10435 S.
Diag(IsStringLocation ? Loc : StringRange.getBegin(),
10436 diag::note_format_string_defined);
10438 Note << StringRange;
10447class CheckPrintfHandler :
public CheckFormatHandler {
10449 CheckPrintfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
10450 const Expr *origFormatExpr,
10452 unsigned numDataArgs,
bool isObjC,
const char *beg,
10456 llvm::SmallBitVector &CheckedVarArgs,
10457 UncoveredArgHandler &UncoveredArg)
10458 : CheckFormatHandler(
s, fexpr, origFormatExpr, type, firstDataArg,
10459 numDataArgs, beg, APK, Args, formatIdx,
10460 inFunctionCall, CallType, CheckedVarArgs,
10466 bool allowsObjCArg()
const {
10471 bool HandleInvalidPrintfConversionSpecifier(
10473 const char *startSpecifier,
10474 unsigned specifierLen)
override;
10476 void handleInvalidMaskType(StringRef MaskType)
override;
10479 const char *startSpecifier,
unsigned specifierLen,
10482 const char *StartSpecifier,
10483 unsigned SpecifierLen,
10487 const char *startSpecifier,
unsigned specifierLen);
10491 const char *startSpecifier,
unsigned specifierLen);
10494 const char *startSpecifier,
unsigned specifierLen);
10498 const char *startSpecifier,
unsigned specifierLen);
10502 void HandleEmptyObjCModifierFlag(
const char *startFlag,
10503 unsigned flagLen)
override;
10505 void HandleInvalidObjCModifierFlag(
const char *startFlag,
10506 unsigned flagLen)
override;
10508 void HandleObjCFlagsWithNonObjCConversion(
const char *flagsStart,
10509 const char *flagsEnd,
10510 const char *conversionPosition)
10516bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
10518 const char *startSpecifier,
10519 unsigned specifierLen) {
10521 FS.getConversionSpecifier();
10523 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
10525 startSpecifier, specifierLen,
10529void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
10530 S.
Diag(getLocationOfByte(MaskType.data()), diag::err_invalid_mask_type_size);
10533bool CheckPrintfHandler::HandleAmount(
10535 const char *startSpecifier,
unsigned specifierLen) {
10539 if (argIndex >= NumDataArgs) {
10540 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_missing_arg)
10542 getLocationOfByte(Amt.
getStart()),
10544 getSpecifierRange(startSpecifier, specifierLen));
10554 CoveredArgs.set(argIndex);
10555 const Expr *Arg = getDataArg(argIndex);
10565 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_asterisk_wrong_type)
10568 getLocationOfByte(Amt.
getStart()),
10570 getSpecifierRange(startSpecifier, specifierLen));
10580void CheckPrintfHandler::HandleInvalidAmount(
10584 const char *startSpecifier,
10585 unsigned specifierLen) {
10587 FS.getConversionSpecifier();
10595 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_optional_amount)
10597 getLocationOfByte(Amt.
getStart()),
10599 getSpecifierRange(startSpecifier, specifierLen),
10605 const char *startSpecifier,
10606 unsigned specifierLen) {
10609 FS.getConversionSpecifier();
10610 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_nonsensical_flag)
10614 getSpecifierRange(startSpecifier, specifierLen),
10619void CheckPrintfHandler::HandleIgnoredFlag(
10623 const char *startSpecifier,
10624 unsigned specifierLen) {
10626 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_ignored_flag)
10630 getSpecifierRange(startSpecifier, specifierLen),
10632 getSpecifierRange(ignoredFlag.
getPosition(), 1)));
10635void CheckPrintfHandler::HandleEmptyObjCModifierFlag(
const char *startFlag,
10636 unsigned flagLen) {
10638 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_empty_objc_flag),
10639 getLocationOfByte(startFlag),
10641 getSpecifierRange(startFlag, flagLen));
10644void CheckPrintfHandler::HandleInvalidObjCModifierFlag(
const char *startFlag,
10645 unsigned flagLen) {
10647 auto Range = getSpecifierRange(startFlag, flagLen);
10648 StringRef flag(startFlag, flagLen);
10649 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_invalid_objc_flag) << flag,
10650 getLocationOfByte(startFlag),
10655void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
10656 const char *flagsStart,
const char *flagsEnd,
const char *conversionPosition) {
10658 auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
10659 auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
10660 EmitFormatDiagnostic(S.
PDiag(diag) << StringRef(conversionPosition, 1),
10661 getLocationOfByte(conversionPosition),
10669template<
typename MemberKind>
10672 const RecordType *RT = Ty->
getAs<RecordType>();
10677 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
10690 if (MemberKind *FK = dyn_cast<MemberKind>(
decl))
10691 Results.insert(FK);
10703 MethodSet Results =
10705 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
10707 if ((*MI)->getMinRequiredArguments() == 0)
10715bool CheckPrintfHandler::checkForCStrMembers(
10719 MethodSet Results =
10722 for (MethodSet::iterator MI = Results.begin(), ME = Results.end();
10725 if (Method->getMinRequiredArguments() == 0 &&
10738bool CheckPrintfHandler::HandlePrintfSpecifier(
10740 unsigned specifierLen,
const TargetInfo &Target) {
10741 using namespace analyze_format_string;
10742 using namespace analyze_printf;
10744 const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
10746 if (FS.consumesDataArgument()) {
10748 atFirstArg =
false;
10749 usesPositionalArgs = FS.usesPositionalArg();
10751 else if (usesPositionalArgs != FS.usesPositionalArg()) {
10752 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
10753 startSpecifier, specifierLen);
10760 if (!HandleAmount(FS.getFieldWidth(), 0,
10761 startSpecifier, specifierLen)) {
10765 if (!HandleAmount(FS.getPrecision(), 1,
10766 startSpecifier, specifierLen)) {
10770 if (!CS.consumesDataArgument()) {
10777 unsigned argIndex = FS.getArgIndex();
10778 if (argIndex < NumDataArgs) {
10782 CoveredArgs.set(argIndex);
10786 if (CS.getKind() == ConversionSpecifier::FreeBSDbArg ||
10787 CS.getKind() == ConversionSpecifier::FreeBSDDArg) {
10789 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex + 1))
10793 CoveredArgs.set(argIndex + 1);
10796 const Expr *Ex = getDataArg(argIndex);
10798 (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
10801 EmitFormatDiagnostic(
10802 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
10806 getSpecifierRange(startSpecifier, specifierLen));
10809 Ex = getDataArg(argIndex + 1);
10812 EmitFormatDiagnostic(
10813 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
10817 getSpecifierRange(startSpecifier, specifierLen));
10824 if (!allowsObjCArg() && CS.isObjCArg()) {
10825 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
10830 if (FSType !=
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::PArg) {
10831 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
10836 if (FSType ==
Sema::FST_OSLog && CS.getKind() == ConversionSpecifier::nArg) {
10837 EmitFormatDiagnostic(S.
PDiag(diag::warn_os_log_format_narg),
10838 getLocationOfByte(CS.getStart()),
10840 getSpecifierRange(startSpecifier, specifierLen));
10847 (CS.getKind() == ConversionSpecifier::PArg ||
10848 CS.getKind() == ConversionSpecifier::sArg ||
10849 CS.getKind() == ConversionSpecifier::ObjCObjArg)) {
10850 return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
10856 if (FS.isPublic().isSet()) {
10857 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
10859 getLocationOfByte(FS.isPublic().getPosition()),
10861 getSpecifierRange(startSpecifier, specifierLen));
10863 if (FS.isPrivate().isSet()) {
10864 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_invalid_annotation)
10866 getLocationOfByte(FS.isPrivate().getPosition()),
10868 getSpecifierRange(startSpecifier, specifierLen));
10872 const llvm::Triple &Triple = Target.getTriple();
10873 if (CS.getKind() == ConversionSpecifier::nArg &&
10874 (Triple.isAndroid() || Triple.isOSFuchsia())) {
10875 EmitFormatDiagnostic(S.
PDiag(diag::warn_printf_narg_not_supported),
10876 getLocationOfByte(CS.getStart()),
10878 getSpecifierRange(startSpecifier, specifierLen));
10882 if (!FS.hasValidFieldWidth()) {
10883 HandleInvalidAmount(FS, FS.getFieldWidth(), 0,
10884 startSpecifier, specifierLen);
10888 if (!FS.hasValidPrecision()) {
10889 HandleInvalidAmount(FS, FS.getPrecision(), 1,
10890 startSpecifier, specifierLen);
10894 if (CS.getKind() == ConversionSpecifier::PArg &&
10895 FS.getPrecision().getHowSpecified() == OptionalAmount::NotSpecified) {
10896 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_P_no_precision),
10897 getLocationOfByte(startSpecifier),
10899 getSpecifierRange(startSpecifier, specifierLen));
10903 if (!FS.hasValidThousandsGroupingPrefix())
10904 HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen);
10905 if (!FS.hasValidLeadingZeros())
10906 HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
10907 if (!FS.hasValidPlusPrefix())
10908 HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
10909 if (!FS.hasValidSpacePrefix())
10910 HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
10911 if (!FS.hasValidAlternativeForm())
10912 HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
10913 if (!FS.hasValidLeftJustified())
10914 HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
10917 if (FS.hasSpacePrefix() && FS.hasPlusPrefix())
10918 HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
10919 startSpecifier, specifierLen);
10920 if (FS.hasLeadingZeros() && FS.isLeftJustified())
10921 HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
10922 startSpecifier, specifierLen);
10927 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
10928 diag::warn_format_nonsensical_length);
10929 else if (!FS.hasStandardLengthModifier())
10930 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
10931 else if (!FS.hasStandardLengthConversionCombination())
10932 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
10933 diag::warn_format_non_standard_conversion_spec);
10935 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
10936 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
10942 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
10945 const Expr *Arg = getDataArg(argIndex);
10949 return checkFormatExpr(FS, startSpecifier, specifierLen, Arg);
10961 case Stmt::ArraySubscriptExprClass:
10962 case Stmt::CallExprClass:
10963 case Stmt::CharacterLiteralClass:
10964 case Stmt::CXXBoolLiteralExprClass:
10965 case Stmt::DeclRefExprClass:
10966 case Stmt::FloatingLiteralClass:
10967 case Stmt::IntegerLiteralClass:
10968 case Stmt::MemberExprClass:
10969 case Stmt::ObjCArrayLiteralClass:
10970 case Stmt::ObjCBoolLiteralExprClass:
10971 case Stmt::ObjCBoxedExprClass:
10972 case Stmt::ObjCDictionaryLiteralClass:
10973 case Stmt::ObjCEncodeExprClass:
10974 case Stmt::ObjCIvarRefExprClass:
10975 case Stmt::ObjCMessageExprClass:
10976 case Stmt::ObjCPropertyRefExprClass:
10977 case Stmt::ObjCStringLiteralClass:
10978 case Stmt::ObjCSubscriptRefExprClass:
10979 case Stmt::ParenExprClass:
10980 case Stmt::StringLiteralClass:
10981 case Stmt::UnaryOperatorClass:
10988static std::pair<QualType, StringRef>
10995 StringRef Name = UserTy->getDecl()->getName();
10996 QualType CastTy = llvm::StringSwitch<QualType>(Name)
11000 .Case(
"SInt32", Context.
IntTy)
11005 return std::make_pair(CastTy, Name);
11007 TyTy = UserTy->desugar();
11011 if (
const ParenExpr *PE = dyn_cast<ParenExpr>(E))
11013 PE->getSubExpr()->getType(),
11022 StringRef TrueName, FalseName;
11024 std::tie(TrueTy, TrueName) =
11026 CO->getTrueExpr()->getType(),
11027 CO->getTrueExpr());
11028 std::tie(FalseTy, FalseName) =
11030 CO->getFalseExpr()->getType(),
11031 CO->getFalseExpr());
11033 if (TrueTy == FalseTy)
11034 return std::make_pair(TrueTy, TrueName);
11035 else if (TrueTy.
isNull())
11036 return std::make_pair(FalseTy, FalseName);
11037 else if (FalseTy.
isNull())
11038 return std::make_pair(TrueTy, TrueName);
11041 return std::make_pair(
QualType(), StringRef());
11060 From = VecTy->getElementType();
11062 To = VecTy->getElementType();
11070 const char *StartSpecifier,
11071 unsigned SpecifierLen,
11073 using namespace analyze_format_string;
11074 using namespace analyze_printf;
11083 while (
const TypeOfExprType *TET = dyn_cast<TypeOfExprType>(ExprTy)) {
11084 ExprTy = TET->getUnderlyingExpr()->getType();
11096 if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::cArg &&
11099 getSpecifierRange(StartSpecifier, SpecifierLen);
11101 llvm::raw_svector_ostream os(FSString);
11103 EmitFormatDiagnostic(S.
PDiag(diag::warn_format_bool_as_character)
11109 ArgType::MatchKind ImplicitMatch = ArgType::NoMatch;
11111 if (Match == ArgType::Match)
11115 assert(Match != ArgType::NoMatchPromotionTypeConfusion);
11124 E = ICE->getSubExpr();
11134 if (ImplicitMatch == ArgType::Match)
11145 FS.getLengthModifier().getKind() != LengthModifier::AsChar)
11152 if (Match == ArgType::MatchPromotion)
11153 Match = ArgType::NoMatch;
11156 if (Match == ArgType::MatchPromotion) {
11160 ImplicitMatch != ArgType::NoMatchPromotionTypeConfusion &&
11161 ImplicitMatch != ArgType::NoMatchTypeConfusion)
11163 Match = ArgType::NoMatch;
11165 if (ImplicitMatch == ArgType::NoMatchPedantic ||
11166 ImplicitMatch == ArgType::NoMatchTypeConfusion)
11167 Match = ImplicitMatch;
11168 assert(Match != ArgType::MatchPromotion);
11171 bool IsEnum =
false;
11172 bool IsScopedEnum =
false;
11174 if (
auto EnumTy = ExprTy->
getAs<EnumType>()) {
11175 IntendedTy = EnumTy->getDecl()->getIntegerType();
11176 if (EnumTy->isUnscopedEnumerationType()) {
11177 ExprTy = IntendedTy;
11182 IsScopedEnum =
true;
11189 if (isObjCContext() &&
11190 FS.getConversionSpecifier().getKind() == ConversionSpecifier::CArg) {
11200 const llvm::APInt &
V = IL->getValue();
11210 if (TD->getUnderlyingType() == IntendedTy)
11218 bool ShouldNotPrintDirectly =
false; StringRef CastTyName;
11226 if (!IsScopedEnum &&
11227 (CastTyName ==
"NSInteger" || CastTyName ==
"NSUInteger") &&
11230 Match = ArgType::NoMatchPedantic;
11231 IntendedTy = CastTy;
11232 ShouldNotPrintDirectly =
true;
11237 PrintfSpecifier fixedFS = FS;
11244 llvm::raw_svector_ostream os(buf);
11245 fixedFS.toString(os);
11247 CharSourceRange SpecRange = getSpecifierRange(StartSpecifier, SpecifierLen);
11249 if (IntendedTy == ExprTy && !ShouldNotPrintDirectly && !IsScopedEnum) {
11252 case ArgType::Match:
11253 case ArgType::MatchPromotion:
11254 case ArgType::NoMatchPromotionTypeConfusion:
11255 llvm_unreachable(
"expected non-matching");
11256 case ArgType::NoMatchPedantic:
11257 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
11259 case ArgType::NoMatchTypeConfusion:
11260 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
11262 case ArgType::NoMatch:
11263 Diag = diag::warn_format_conversion_argument_type_mismatch;
11284 llvm::raw_svector_ostream CastFix(CastBuf);
11285 CastFix << (S.
LangOpts.CPlusPlus ?
"static_cast<" :
"(");
11287 CastFix << (S.
LangOpts.CPlusPlus ?
">" :
")");
11291 ShouldNotPrintDirectly)
11294 if (
const CStyleCastExpr *CCast = dyn_cast<CStyleCastExpr>(E)) {
11296 SourceRange CastRange(CCast->getLParenLoc(), CCast->getRParenLoc());
11318 if (ShouldNotPrintDirectly && !IsScopedEnum) {
11324 Name = TypedefTy->getDecl()->getName();
11327 unsigned Diag = Match == ArgType::NoMatchPedantic
11328 ? diag::warn_format_argument_needs_cast_pedantic
11329 : diag::warn_format_argument_needs_cast;
11330 EmitFormatDiagnostic(S.
PDiag(
Diag) << Name << IntendedTy << IsEnum
11338 EmitFormatDiagnostic(
11339 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
11351 bool EmitTypeMismatch =
false;
11357 case ArgType::Match:
11358 case ArgType::MatchPromotion:
11359 case ArgType::NoMatchPromotionTypeConfusion:
11360 llvm_unreachable(
"expected non-matching");
11361 case ArgType::NoMatchPedantic:
11362 Diag = diag::warn_format_conversion_argument_type_mismatch_pedantic;
11364 case ArgType::NoMatchTypeConfusion:
11365 Diag = diag::warn_format_conversion_argument_type_mismatch_confusion;
11367 case ArgType::NoMatch:
11368 Diag = diag::warn_format_conversion_argument_type_mismatch;
11372 EmitFormatDiagnostic(
11381 EmitTypeMismatch =
true;
11383 EmitFormatDiagnostic(
11384 S.
PDiag(diag::warn_non_pod_vararg_with_format_string)
11385 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
11389 checkForCStrMembers(AT, E);
11395 EmitTypeMismatch =
true;
11397 EmitFormatDiagnostic(
11398 S.
PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
11399 << S.
getLangOpts().CPlusPlus11 << ExprTy << CallType
11412 if (EmitTypeMismatch) {
11418 EmitFormatDiagnostic(
11419 S.
PDiag(diag::warn_format_conversion_argument_type_mismatch)
11425 assert(FirstDataArg + FS.getArgIndex() < CheckedVarArgs.size() &&
11426 "format string specifier index out of range");
11427 CheckedVarArgs[FirstDataArg + FS.getArgIndex()] =
true;
11437class CheckScanfHandler :
public CheckFormatHandler {
11439 CheckScanfHandler(
Sema &
s,
const FormatStringLiteral *fexpr,
11441 unsigned firstDataArg,
unsigned numDataArgs,
11445 llvm::SmallBitVector &CheckedVarArgs,
11446 UncoveredArgHandler &UncoveredArg)
11447 : CheckFormatHandler(
s, fexpr, origFormatExpr, type, firstDataArg,
11448 numDataArgs, beg, APK, Args, formatIdx,
11449 inFunctionCall, CallType, CheckedVarArgs,
11453 const char *startSpecifier,
11454 unsigned specifierLen)
override;
11456 bool HandleInvalidScanfConversionSpecifier(
11458 const char *startSpecifier,
11459 unsigned specifierLen)
override;
11461 void HandleIncompleteScanList(
const char *start,
const char *end)
override;
11466void CheckScanfHandler::HandleIncompleteScanList(
const char *start,
11468 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_scanlist_incomplete),
11469 getLocationOfByte(end),
true,
11470 getSpecifierRange(start, end - start));
11473bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
11475 const char *startSpecifier,
11476 unsigned specifierLen) {
11478 FS.getConversionSpecifier();
11480 return HandleInvalidConversionSpecifier(FS.getArgIndex(),
11482 startSpecifier, specifierLen,
11486bool CheckScanfHandler::HandleScanfSpecifier(
11488 const char *startSpecifier,
11489 unsigned specifierLen) {
11490 using namespace analyze_scanf;
11491 using namespace analyze_format_string;
11493 const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
11497 if (FS.consumesDataArgument()) {
11499 atFirstArg =
false;
11500 usesPositionalArgs = FS.usesPositionalArg();
11502 else if (usesPositionalArgs != FS.usesPositionalArg()) {
11503 HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
11504 startSpecifier, specifierLen);
11510 const OptionalAmount &Amt = FS.getFieldWidth();
11511 if (Amt.getHowSpecified() == OptionalAmount::Constant) {
11512 if (Amt.getConstantAmount() == 0) {
11514 Amt.getConstantLength());
11515 EmitFormatDiagnostic(S.
PDiag(diag::warn_scanf_nonzero_width),
11516 getLocationOfByte(Amt.getStart()),
11522 if (!FS.consumesDataArgument()) {
11529 unsigned argIndex = FS.getArgIndex();
11530 if (argIndex < NumDataArgs) {
11534 CoveredArgs.set(argIndex);
11540 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
11541 diag::warn_format_nonsensical_length);
11542 else if (!FS.hasStandardLengthModifier())
11543 HandleNonStandardLengthModifier(FS, startSpecifier, specifierLen);
11544 else if (!FS.hasStandardLengthConversionCombination())
11545 HandleInvalidLengthModifier(FS, CS, startSpecifier, specifierLen,
11546 diag::warn_format_non_standard_conversion_spec);
11548 if (!FS.hasStandardConversionSpecifier(S.
getLangOpts()))
11549 HandleNonStandardConversionSpecifier(CS, startSpecifier, specifierLen);
11555 if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
11559 const Expr *Ex = getDataArg(argIndex);
11575 ScanfSpecifier fixedFS = FS;
11580 Pedantic ? diag::warn_format_conversion_argument_type_mismatch_pedantic
11581 : diag::warn_format_conversion_argument_type_mismatch;
11586 llvm::raw_svector_ostream os(buf);
11587 fixedFS.toString(os);
11589 EmitFormatDiagnostic(
11594 getSpecifierRange(startSpecifier, specifierLen),
11596 getSpecifierRange(startSpecifier, specifierLen), os.str()));
11603 getSpecifierRange(startSpecifier, specifierLen));
11610 Sema &S,
const FormatStringLiteral *FExpr,
const Expr *OrigFormatExpr,
11614 llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
11615 bool IgnoreStringsWithoutSpecifiers) {
11617 if (!FExpr->isAscii() && !FExpr->isUTF8()) {
11618 CheckFormatHandler::EmitFormatDiagnostic(
11619 S, inFunctionCall, Args[format_idx],
11620 S.
PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
11626 StringRef StrRef = FExpr->getString();
11627 const char *Str = StrRef.data();
11631 assert(T &&
"String literal not of constant array type!");
11632 size_t TypeSize = T->getSize().getZExtValue();
11633 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
11634 const unsigned numDataArgs = Args.size() - firstDataArg;
11636 if (IgnoreStringsWithoutSpecifiers &&
11643 if (TypeSize <= StrRef.size() && !StrRef.substr(0, TypeSize).contains(
'\0')) {
11644 CheckFormatHandler::EmitFormatDiagnostic(
11645 S, inFunctionCall, Args[format_idx],
11646 S.
PDiag(diag::warn_printf_format_string_not_null_terminated),
11647 FExpr->getBeginLoc(),
11653 if (StrLen == 0 && numDataArgs > 0) {
11654 CheckFormatHandler::EmitFormatDiagnostic(
11655 S, inFunctionCall, Args[format_idx],
11656 S.
PDiag(diag::warn_empty_format_string), FExpr->getBeginLoc(),
11664 CheckPrintfHandler H(
11665 S, FExpr, OrigFormatExpr,
Type, firstDataArg, numDataArgs,
11667 Args, format_idx, inFunctionCall, CallType, CheckedVarArgs,
11673 H.DoneProcessing();
11675 CheckScanfHandler H(S, FExpr, OrigFormatExpr,
Type, firstDataArg,
11676 numDataArgs, Str, APK, Args, format_idx, inFunctionCall,
11677 CallType, CheckedVarArgs, UncoveredArg);
11681 H.DoneProcessing();
11688 const char *Str = StrRef.data();
11691 assert(T &&
"String literal not of constant array type!");
11692 size_t TypeSize = T->getSize().getZExtValue();
11693 size_t StrLen = std::min(std::max(TypeSize,
size_t(1)) - 1, StrRef.size());
11704 switch (AbsFunction) {
11708 case Builtin::BI__builtin_abs:
11709 return Builtin::BI__builtin_labs;
11710 case Builtin::BI__builtin_labs:
11711 return Builtin::BI__builtin_llabs;
11712 case Builtin::BI__builtin_llabs:
11715 case Builtin::BI__builtin_fabsf:
11716 return Builtin::BI__builtin_fabs;
11717 case Builtin::BI__builtin_fabs:
11718 return Builtin::BI__builtin_fabsl;
11719 case Builtin::BI__builtin_fabsl:
11722 case Builtin::BI__builtin_cabsf:
11723 return Builtin::BI__builtin_cabs;
11724 case Builtin::BI__builtin_cabs:
11725 return Builtin::BI__builtin_cabsl;
11726 case Builtin::BI__builtin_cabsl:
11729 case Builtin::BIabs:
11730 return Builtin::BIlabs;
11731 case Builtin::BIlabs:
11732 return Builtin::BIllabs;
11733 case Builtin::BIllabs:
11736 case Builtin::BIfabsf:
11737 return Builtin::BIfabs;
11738 case Builtin::BIfabs:
11739 return Builtin::BIfabsl;
11740 case Builtin::BIfabsl:
11743 case Builtin::BIcabsf:
11744 return Builtin::BIcabs;
11745 case Builtin::BIcabs:
11746 return Builtin::BIcabsl;
11747 case Builtin::BIcabsl:
11754 unsigned AbsType) {
11776 unsigned AbsFunctionKind) {
11777 unsigned BestKind = 0;
11779 for (
unsigned Kind = AbsFunctionKind; Kind != 0;
11785 else if (Context.
hasSameType(ParamType, ArgType)) {
11801 if (T->isIntegralOrEnumerationType())
11803 if (T->isRealFloatingType())
11805 if (T->isAnyComplexType())
11808 llvm_unreachable(
"Type not integer, floating, or complex");
11815 switch (ValueKind) {
11820 case Builtin::BI__builtin_fabsf:
11821 case Builtin::BI__builtin_fabs:
11822 case Builtin::BI__builtin_fabsl:
11823 case Builtin::BI__builtin_cabsf:
11824 case Builtin::BI__builtin_cabs:
11825 case Builtin::BI__builtin_cabsl:
11826 return Builtin::BI__builtin_abs;
11827 case Builtin::BIfabsf:
11828 case Builtin::BIfabs:
11829 case Builtin::BIfabsl:
11830 case Builtin::BIcabsf:
11831 case Builtin::BIcabs:
11832 case Builtin::BIcabsl:
11833 return Builtin::BIabs;
11839 case Builtin::BI__builtin_abs:
11840 case Builtin::BI__builtin_labs:
11841 case Builtin::BI__builtin_llabs:
11842 case Builtin::BI__builtin_cabsf:
11843 case Builtin::BI__builtin_cabs:
11844 case Builtin::BI__builtin_cabsl:
11845 return Builtin::BI__builtin_fabsf;
11846 case Builtin::BIabs:
11847 case Builtin::BIlabs:
11848 case Builtin::BIllabs:
11849 case Builtin::BIcabsf:
11850 case Builtin::BIcabs:
11851 case Builtin::BIcabsl:
11852 return Builtin::BIfabsf;
11858 case Builtin::BI__builtin_abs:
11859 case Builtin::BI__builtin_labs:
11860 case Builtin::BI__builtin_llabs:
11861 case Builtin::BI__builtin_fabsf:
11862 case Builtin::BI__builtin_fabs:
11863 case Builtin::BI__builtin_fabsl:
11864 return Builtin::BI__builtin_cabsf;
11865 case Builtin::BIabs:
11866 case Builtin::BIlabs:
11867 case Builtin::BIllabs:
11868 case Builtin::BIfabsf:
11869 case Builtin::BIfabs:
11870 case Builtin::BIfabsl:
11871 return Builtin::BIcabsf;
11874 llvm_unreachable(
"Unable to convert function");
11885 case Builtin::BI__builtin_abs:
11886 case Builtin::BI__builtin_fabs:
11887 case Builtin::BI__builtin_fabsf:
11888 case Builtin::BI__builtin_fabsl:
11889 case Builtin::BI__builtin_labs:
11890 case Builtin::BI__builtin_llabs:
11891 case Builtin::BI__builtin_cabs:
11892 case Builtin::BI__builtin_cabsf:
11893 case Builtin::BI__builtin_cabsl:
11894 case Builtin::BIabs:
11895 case Builtin::BIlabs:
11896 case Builtin::BIllabs:
11897 case Builtin::BIfabs:
11898 case Builtin::BIfabsf:
11899 case Builtin::BIfabsl:
11900 case Builtin::BIcabs:
11901 case Builtin::BIcabsf:
11902 case Builtin::BIcabsl:
11905 llvm_unreachable(
"Unknown Builtin type");
11911 unsigned AbsKind,
QualType ArgType) {
11912 bool EmitHeaderHint =
true;
11913 const char *HeaderName =
nullptr;
11914 StringRef FunctionName;
11915 if (S.
getLangOpts().CPlusPlus && !ArgType->isAnyComplexType()) {
11916 FunctionName =
"std::abs";
11917 if (ArgType->isIntegralOrEnumerationType()) {
11918 HeaderName =
"cstdlib";
11919 }
else if (ArgType->isRealFloatingType()) {
11920 HeaderName =
"cmath";
11922 llvm_unreachable(
"Invalid Type");
11931 for (
const auto *I : R) {
11934 FDecl = dyn_cast<FunctionDecl>(UsingD->getTargetDecl());
11936 FDecl = dyn_cast<FunctionDecl>(I);
11951 EmitHeaderHint =
false;
11969 EmitHeaderHint =
false;
11973 }
else if (!R.
empty()) {
11979 S.
Diag(Loc, diag::note_replace_abs_function)
11985 if (!EmitHeaderHint)
11988 S.
Diag(Loc, diag::note_include_header_or_declare) << HeaderName
11992template <std::
size_t StrLen>
11994 const char (&Str)[StrLen]) {
12006void Sema::CheckAbsoluteValueFunction(
const CallExpr *Call,
12008 if (
Call->getNumArgs() != 1)
12013 if (AbsKind == 0 && !IsStdAbs)
12016 QualType ArgType =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
12021 if (ArgType->isUnsignedIntegerType()) {
12022 StringRef FunctionName =
12024 Diag(
Call->getExprLoc(), diag::warn_unsigned_abs) << ArgType << ParamType;
12025 Diag(
Call->getExprLoc(), diag::note_remove_abs)
12033 if (ArgType->isPointerType() || ArgType->canDecayToPointerType()) {
12034 unsigned DiagType = 0;
12035 if (ArgType->isFunctionType())
12037 else if (ArgType->isArrayType())
12040 Diag(
Call->getExprLoc(), diag::warn_pointer_abs) << DiagType << ArgType;
12054 if (ArgValueKind == ParamValueKind) {
12059 Diag(
Call->getExprLoc(), diag::warn_abs_too_small)
12060 << FDecl << ArgType << ParamType;
12062 if (NewAbsKind == 0)
12066 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
12075 if (NewAbsKind == 0)
12078 Diag(
Call->getExprLoc(), diag::warn_wrong_absolute_value_type)
12079 << FDecl << ParamValueKind << ArgValueKind;
12082 Call->getCallee()->getSourceRange(), NewAbsKind, ArgType);
12086void Sema::CheckMaxUnsignedZero(
const CallExpr *Call,
12088 if (!Call || !FDecl)
return;
12092 if (
Call->getExprLoc().isMacroID())
return;
12095 if (
Call->getNumArgs() != 2)
return;
12098 if (!ArgList)
return;
12099 if (ArgList->size() != 1)
return;
12102 const auto& TA = ArgList->
get(0);
12104 QualType ArgType = TA.getAsType();
12105 if (!ArgType->isUnsignedIntegerType())
return;
12108 auto IsLiteralZeroArg = [](
const Expr* E) ->
bool {
12109 const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E);
12110 if (!MTE)
return false;
12111 const auto *Num = dyn_cast<IntegerLiteral>(MTE->getSubExpr());
12112 if (!Num)
return false;
12113 if (Num->getValue() != 0)
return false;
12117 const Expr *FirstArg =
Call->getArg(0);
12118 const Expr *SecondArg =
Call->getArg(1);
12119 const bool IsFirstArgZero = IsLiteralZeroArg(FirstArg);
12120 const bool IsSecondArgZero = IsLiteralZeroArg(SecondArg);
12123 if (IsFirstArgZero == IsSecondArgZero)
return;
12128 SourceRange ZeroRange = IsFirstArgZero ? FirstRange : SecondRange;
12130 Diag(
Call->getExprLoc(), diag::warn_max_unsigned_zero)
12131 << IsFirstArgZero <<
Call->getCallee()->getSourceRange() << ZeroRange;
12135 if (IsFirstArgZero) {
12143 Diag(
Call->getExprLoc(), diag::note_remove_max_call)
12163 if (!Size->isComparisonOp() && !Size->isLogicalOp())
12167 S.
Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison)
12168 << SizeRange << FnName;
12169 S.
Diag(FnLoc, diag::note_memsize_comparison_paren)
12174 S.
Diag(SizeRange.
getBegin(), diag::note_memsize_comparison_cast_silence)
12185 bool &IsContained) {
12188 IsContained =
false;
12201 for (
auto *FD : RD->
fields()) {
12205 IsContained =
true;
12206 return ContainedRD;
12214 if (
const auto *Unary = dyn_cast<UnaryExprOrTypeTraitExpr>(E))
12215 if (Unary->getKind() == UETT_SizeOf)
12224 if (!SizeOf->isArgumentType())
12232 return SizeOf->getTypeOfArgument();
12238struct SearchNonTrivialToInitializeField
12243 SearchNonTrivialToInitializeField(
const Expr *E,
Sema &S) : E(E), S(S) {}
12247 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
12248 asDerived().visitArray(PDIK, AT, SL);
12252 Super::visitWithKind(PDIK, FT, SL);
12262 for (
const FieldDecl *FD : FT->
castAs<RecordType>()->getDecl()->fields())
12267 visit(getContext().getBaseElementType(AT), SL);
12272 SearchNonTrivialToInitializeField(E, S).visitStruct(RT,
SourceLocation());
12281struct SearchNonTrivialToCopyField
12285 SearchNonTrivialToCopyField(
const Expr *E,
Sema &S) : E(E), S(S) {}
12289 if (
const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
12290 asDerived().visitArray(PCK, AT, SL);
12294 Super::visitWithKind(PCK, FT, SL);
12304 for (
const FieldDecl *FD : FT->
castAs<RecordType>()->getDecl()->fields())
12309 visit(getContext().getBaseElementType(AT), SL);
12317 SearchNonTrivialToCopyField(E, S).visitStruct(RT,
SourceLocation());
12332 if (
const auto *BO = dyn_cast<BinaryOperator>(SizeofExpr)) {
12333 if (BO->getOpcode() != BO_Mul && BO->getOpcode() != BO_Add)
12357 return SM.getFileID(CallLoc) !=
SM.getFileID(ArgLoc);
12359 return SM.getFileID(
SM.getImmediateMacroCallerLoc(CallLoc)) !=
12360 SM.getFileID(
SM.getImmediateMacroCallerLoc(ArgLoc));
12366 if (BId != Builtin::BImemset && BId != Builtin::BIbzero)
12369 const Expr *SizeArg =
12370 Call->getArg(BId == Builtin::BImemset ? 2 : 1)->IgnoreImpCasts();
12372 auto isLiteralZero = [](
const Expr *E) {
12373 return (isa<IntegerLiteral>(E) &&
12374 cast<IntegerLiteral>(E)->getValue() == 0) ||
12382 if (isLiteralZero(SizeArg) &&
12389 if (BId == Builtin::BIbzero ||
12392 S.
Diag(DiagLoc, diag::warn_suspicious_bzero_size);
12393 S.
Diag(DiagLoc, diag::note_suspicious_bzero_size_silence);
12394 }
else if (!isLiteralZero(Call->getArg(1)->IgnoreImpCasts())) {
12395 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 0;
12396 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 0;
12404 if (BId == Builtin::BImemset &&
12408 S.
Diag(DiagLoc, diag::warn_suspicious_sizeof_memset) << 1;
12409 S.
Diag(DiagLoc, diag::note_suspicious_sizeof_memset_silence) << 1;
12421void Sema::CheckMemaccessArguments(
const CallExpr *Call,
12428 unsigned ExpectedNumArgs =
12429 (BId == Builtin::BIstrndup || BId == Builtin::BIbzero ? 2 : 3);
12430 if (
Call->getNumArgs() < ExpectedNumArgs)
12433 unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
12434 BId == Builtin::BIstrndup ? 1 : 2);
12436 (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
12437 const Expr *LenExpr =
Call->getArg(LenArg)->IgnoreParenImpCasts();
12440 Call->getBeginLoc(),
Call->getRParenLoc()))
12449 llvm::FoldingSetNodeID SizeOfArgID;
12454 QualType FirstArgTy =
Call->getArg(0)->IgnoreParenImpCasts()->getType();
12458 for (
unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {
12459 const Expr *Dest =
Call->getArg(ArgIdx)->IgnoreParenImpCasts();
12481 if (SizeOfArgID == llvm::FoldingSetNodeID())
12483 llvm::FoldingSetNodeID DestID;
12485 if (DestID == SizeOfArgID) {
12488 unsigned ActionIdx = 0;
12489 StringRef ReadableName = FnName->
getName();
12491 if (
const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest))
12492 if (UnaryOp->getOpcode() == UO_AddrOf)
12506 if (
SM.isMacroArgExpansion(SL)) {
12508 SL =
SM.getSpellingLoc(SL);
12516 PDiag(diag::warn_sizeof_pointer_expr_memaccess)
12523 PDiag(diag::warn_sizeof_pointer_expr_memaccess_note)
12538 PDiag(diag::warn_sizeof_pointer_type_memaccess)
12539 << FnName << SizeOfArgTy << ArgIdx
12546 PointeeTy = DestTy;
12557 unsigned OperationType = 0;
12558 const bool IsCmp = BId == Builtin::BImemcmp || BId == Builtin::BIbcmp;
12561 if (ArgIdx != 0 || IsCmp) {
12562 if (BId == Builtin::BImemcpy)
12564 else if(BId == Builtin::BImemmove)
12571 PDiag(diag::warn_dyn_class_memaccess)
12572 << (IsCmp ? ArgIdx + 2 : ArgIdx) << FnName
12573 << IsContained << ContainedRD << OperationType
12574 <<
Call->getCallee()->getSourceRange());
12576 BId != Builtin::BImemset)
12579 PDiag(diag::warn_arc_object_memaccess)
12580 << ArgIdx << FnName << PointeeTy
12581 <<
Call->getCallee()->getSourceRange());
12582 else if (
const auto *RT = PointeeTy->
getAs<RecordType>()) {
12583 if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
12584 RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
12586 PDiag(diag::warn_cstruct_memaccess)
12587 << ArgIdx << FnName << PointeeTy << 0);
12588 SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *
this);
12589 }
else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
12590 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
12592 PDiag(diag::warn_cstruct_memaccess)
12593 << ArgIdx << FnName << PointeeTy << 1);
12594 SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *
this);
12603 PDiag(diag::note_bad_memaccess_silence)
12623 if (isa<IntegerLiteral>(RHS))
12625 else if (isa<IntegerLiteral>(LHS))
12639 if (CAT->getSize().getSExtValue() <= 1)
12649void Sema::CheckStrlcpycatArguments(
const CallExpr *Call,
12653 unsigned NumArgs =
Call->getNumArgs();
12654 if ((NumArgs != 3) && (NumArgs != 4))
12659 const Expr *CompareWithSrc =
nullptr;
12662 Call->getBeginLoc(),
Call->getRParenLoc()))
12667 CompareWithSrc = Ex;
12670 if (
const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
12671 if (SizeCall->getBuiltinCallee() == Builtin::BIstrlen &&
12672 SizeCall->getNumArgs() == 1)
12677 if (!CompareWithSrc)
12684 const DeclRefExpr *SrcArgDRE = dyn_cast<DeclRefExpr>(SrcArg);
12688 const DeclRefExpr *CompareWithSrcDRE = dyn_cast<DeclRefExpr>(CompareWithSrc);
12689 if (!CompareWithSrcDRE ||
12693 const Expr *OriginalSizeArg =
Call->getArg(2);
12694 Diag(CompareWithSrcDRE->
getBeginLoc(), diag::warn_strlcpycat_wrong_size)
12701 const Expr *DstArg =
Call->getArg(0)->IgnoreParenImpCasts();
12706 llvm::raw_svector_ostream
OS(sizeString);
12711 Diag(OriginalSizeArg->
getBeginLoc(), diag::note_strlcpycat_wrong_size)
12718 if (
const DeclRefExpr *D1 = dyn_cast_or_null<DeclRefExpr>(E1))
12719 if (
const DeclRefExpr *D2 = dyn_cast_or_null<DeclRefExpr>(E2))
12720 return D1->getDecl() == D2->getDecl();
12725 if (
const CallExpr *CE = dyn_cast<CallExpr>(E)) {
12729 return CE->getArg(0)->IgnoreParenCasts();
12737void Sema::CheckStrncatArguments(
const CallExpr *CE,
12752 unsigned PatternType = 0;
12760 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(LenArg)) {
12761 if (BE->getOpcode() == BO_Sub) {
12774 if (PatternType == 0)
12783 if (
SM.isMacroArgExpansion(SL)) {
12784 SL =
SM.getSpellingLoc(SL);
12793 if (!isKnownSizeArray) {
12794 if (PatternType == 1)
12795 Diag(SL, diag::warn_strncat_wrong_size) << SR;
12797 Diag(SL, diag::warn_strncat_src_size) << SR;
12801 if (PatternType == 1)
12802 Diag(SL, diag::warn_strncat_large_size) << SR;
12804 Diag(SL, diag::warn_strncat_src_size) << SR;
12807 llvm::raw_svector_ostream
OS(sizeString);
12815 Diag(SL, diag::note_strncat_wrong_size)
12820void CheckFreeArgumentsOnLvalue(
Sema &S,
const std::string &CalleeName,
12822 if (isa<FieldDecl, FunctionDecl, VarDecl>(D)) {
12829void CheckFreeArgumentsAddressof(
Sema &S,
const std::string &CalleeName,
12831 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->
getSubExpr())) {
12832 const Decl *D = Lvalue->getDecl();
12833 if (isa<DeclaratorDecl>(D))
12834 if (!dyn_cast<DeclaratorDecl>(D)->
getType()->isReferenceType())
12835 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, D);
12838 if (
const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->
getSubExpr()))
12839 return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
12840 Lvalue->getMemberDecl());
12843void CheckFreeArgumentsPlus(
Sema &S,
const std::string &CalleeName,
12845 const auto *Lambda = dyn_cast<LambdaExpr>(
12850 S.
Diag(Lambda->getBeginLoc(), diag::warn_free_nonheap_object)
12851 << CalleeName << 2 ;
12854void CheckFreeArgumentsStackArray(
Sema &S,
const std::string &CalleeName,
12856 const auto *Var = dyn_cast<VarDecl>(Lvalue->
getDecl());
12857 if (Var ==
nullptr)
12861 << CalleeName << 0 << Var;
12864void CheckFreeArgumentsCast(
Sema &S,
const std::string &CalleeName,
12867 llvm::raw_svector_ostream OS(SizeString);
12870 if (Kind == clang::CK_BitCast &&
12871 !
Cast->getSubExpr()->getType()->isFunctionPointerType())
12873 if (Kind == clang::CK_IntegralToPointer &&
12874 !isa<IntegerLiteral>(
12875 Cast->getSubExpr()->IgnoreParenImpCasts()->IgnoreParens()))
12878 switch (
Cast->getCastKind()) {
12879 case clang::CK_BitCast:
12880 case clang::CK_IntegralToPointer:
12881 case clang::CK_FunctionToPointerDecay:
12890 S.
Diag(
Cast->getBeginLoc(), diag::warn_free_nonheap_object)
12891 << CalleeName << 0 << OS.str();
12896void Sema::CheckFreeArguments(
const CallExpr *E) {
12897 const std::string CalleeName =
12902 if (
const auto *UnaryExpr = dyn_cast<UnaryOperator>(Arg))
12904 case UnaryOperator::Opcode::UO_AddrOf:
12905 return CheckFreeArgumentsAddressof(*
this, CalleeName, UnaryExpr);
12906 case UnaryOperator::Opcode::UO_Plus:
12907 return CheckFreeArgumentsPlus(*
this, CalleeName, UnaryExpr);
12912 if (
const auto *Lvalue = dyn_cast<DeclRefExpr>(Arg))
12914 return CheckFreeArgumentsStackArray(*
this, CalleeName, Lvalue);
12916 if (
const auto *
Label = dyn_cast<AddrLabelExpr>(Arg)) {
12917 Diag(
Label->getBeginLoc(), diag::warn_free_nonheap_object)
12918 << CalleeName << 0 <<
Label->getLabel()->getIdentifier();
12922 if (isa<BlockExpr>(Arg)) {
12924 << CalleeName << 1 ;
12929 if (
const auto *Cast = dyn_cast<CastExpr>(E->
getArg(0)))
12930 return CheckFreeArgumentsCast(*
this, CalleeName, Cast);
12934Sema::CheckReturnValExpr(
Expr *RetValExp,
QualType lhsType,
12943 Diag(ReturnLoc, diag::warn_null_ret)
12953 if (Op == OO_New || Op == OO_Array_New) {
12958 Diag(ReturnLoc, diag::warn_operator_new_returns_null)
12964 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
12970 CheckPPCMMAType(RetValExp->
getType(), ReturnLoc);
12983 auto getCastAndLiteral = [&FPLiteral, &FPCast](
Expr *L,
Expr *R) {
12984 FPLiteral = dyn_cast<FloatingLiteral>(L->IgnoreParens());
12986 return FPLiteral && FPCast;
12989 if (getCastAndLiteral(LHS, RHS) || getCastAndLiteral(RHS, LHS)) {
12995 llvm::APFloat TargetC = FPLiteral->
getValue();
12997 llvm::APFloat::rmNearestTiesToEven, &Lossy);
13001 Diag(Loc, diag::warn_float_compare_literal)
13002 << (Opcode == BO_EQ) <<
QualType(SourceTy, 0)
13015 if (
auto *DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
13016 if (
auto *DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
13017 if (DRL->getDecl() == DRR->getDecl())
13025 if (
FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
13026 if (FLL->isExact())
13029 if (
FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen))
13030 if (FLR->isExact())
13034 if (
CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
13035 if (CL->getBuiltinCallee())
13038 if (
CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
13039 if (CR->getBuiltinCallee())
13043 Diag(Loc, diag::warn_floatingpoint_eq)
13064 IntRange(
unsigned Width,
bool NonNegative)
13065 : Width(Width), NonNegative(NonNegative) {}
13068 unsigned valueBits()
const {
13069 return NonNegative ? Width : Width - 1;
13073 static IntRange forBoolType() {
13074 return IntRange(1,
true);
13079 return forValueOfCanonicalType(
C,
13080 T->getCanonicalTypeInternal().getTypePtr());
13084 static IntRange forValueOfCanonicalType(
ASTContext &
C,
const Type *T) {
13085 assert(T->isCanonicalUnqualified());
13087 if (
const VectorType *VT = dyn_cast<VectorType>(T))
13088 T = VT->getElementType().getTypePtr();
13089 if (
const ComplexType *CT = dyn_cast<ComplexType>(T))
13090 T = CT->getElementType().getTypePtr();
13091 if (
const AtomicType *AT = dyn_cast<AtomicType>(T))
13092 T = AT->getValueType().getTypePtr();
13094 if (!
C.getLangOpts().CPlusPlus) {
13096 if (
const EnumType *ET = dyn_cast<EnumType>(T))
13097 T = ET->getDecl()->getIntegerType().getDesugaredType(
C).getTypePtr();
13098 }
else if (
const EnumType *ET = dyn_cast<EnumType>(T)) {
13103 if (
Enum->isFixed()) {
13104 return IntRange(
C.getIntWidth(
QualType(T, 0)),
13105 !ET->isSignedIntegerOrEnumerationType());
13109 unsigned NumNegative =
Enum->getNumNegativeBits();
13111 if (NumNegative == 0)
13112 return IntRange(NumPositive,
true);
13114 return IntRange(std::max(NumPositive + 1, NumNegative),
13118 if (
const auto *EIT = dyn_cast<BitIntType>(T))
13119 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
13132 static IntRange forTargetOfCanonicalType(
ASTContext &
C,
const Type *T) {
13133 assert(T->isCanonicalUnqualified());
13135 if (
const VectorType *VT = dyn_cast<VectorType>(T))
13136 T = VT->getElementType().getTypePtr();
13137 if (
const ComplexType *CT = dyn_cast<ComplexType>(T))
13138 T = CT->getElementType().getTypePtr();
13139 if (
const AtomicType *AT = dyn_cast<AtomicType>(T))
13140 T = AT->getValueType().getTypePtr();
13141 if (
const EnumType *ET = dyn_cast<EnumType>(T))
13142 T =
C.getCanonicalType(ET->getDecl()->getIntegerType()).getTypePtr();
13144 if (
const auto *EIT = dyn_cast<BitIntType>(T))
13145 return IntRange(EIT->getNumBits(), EIT->isUnsigned());
13154 static IntRange join(IntRange L, IntRange R) {
13155 bool Unsigned = L.NonNegative && R.NonNegative;
13156 return IntRange(std::max(L.valueBits(), R.valueBits()) + !
Unsigned,
13157 L.NonNegative && R.NonNegative);
13161 static IntRange bit_and(IntRange L, IntRange R) {
13162 unsigned Bits = std::max(L.Width, R.Width);
13163 bool NonNegative =
false;
13164 if (L.NonNegative) {
13165 Bits = std::min(Bits, L.Width);
13166 NonNegative =
true;
13168 if (R.NonNegative) {
13169 Bits = std::min(Bits, R.Width);
13170 NonNegative =
true;
13172 return IntRange(Bits, NonNegative);
13176 static IntRange sum(IntRange L, IntRange R) {
13177 bool Unsigned = L.NonNegative && R.NonNegative;
13178 return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !
Unsigned,
13183 static IntRange difference(IntRange L, IntRange R) {
13187 bool CanWiden = !L.NonNegative || !R.NonNegative;
13188 bool Unsigned = L.NonNegative && R.Width == 0;
13189 return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
13195 static IntRange product(IntRange L, IntRange R) {
13199 bool CanWiden = !L.NonNegative && !R.NonNegative;
13200 bool Unsigned = L.NonNegative && R.NonNegative;
13201 return IntRange(L.valueBits() + R.valueBits() + CanWiden + !
Unsigned,
13206 static IntRange rem(IntRange L, IntRange R) {
13210 return IntRange(std::min(L.valueBits(), R.valueBits()) + !
Unsigned,
13218 unsigned MaxWidth) {
13219 if (value.isSigned() && value.isNegative())
13220 return IntRange(value.getSignificantBits(),
false);
13222 if (value.getBitWidth() > MaxWidth)
13223 value = value.trunc(MaxWidth);
13227 return IntRange(value.getActiveBits(),
true);
13231 unsigned MaxWidth) {
13232 if (result.
isInt())
13239 R = IntRange::join(R, El);
13247 return IntRange::join(R, I);
13262 Ty = AtomicRHS->getValueType();
13275 bool InConstantContext,
bool Approximate) {
13286 if (
const auto *CE = dyn_cast<ImplicitCastExpr>(E)) {
13287 if (CE->getCastKind() == CK_NoOp || CE->getCastKind() == CK_LValueToRValue)
13288 return GetExprRange(
C, CE->getSubExpr(), MaxWidth, InConstantContext,
13291 IntRange OutputTypeRange = IntRange::forValueOfType(
C,
GetExprType(CE));
13293 bool isIntegerCast = CE->getCastKind() == CK_IntegralCast ||
13294 CE->getCastKind() == CK_BooleanToSignedIntegral;
13297 if (!isIntegerCast)
13298 return OutputTypeRange;
13301 std::min(MaxWidth, OutputTypeRange.Width),
13302 InConstantContext, Approximate);
13305 if (SubRange.Width >= OutputTypeRange.Width)
13306 return OutputTypeRange;
13310 return IntRange(SubRange.Width,
13311 SubRange.NonNegative || OutputTypeRange.NonNegative);
13314 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
13317 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult,
C))
13319 CondResult ? CO->getTrueExpr() : CO->getFalseExpr(),
13320 MaxWidth, InConstantContext, Approximate);
13325 Expr *E = CO->getTrueExpr();
13327 ? IntRange{0,
true}
13328 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
13329 E = CO->getFalseExpr();
13331 ? IntRange{0,
true}
13332 :
GetExprRange(
C, E, MaxWidth, InConstantContext, Approximate);
13333 return IntRange::join(L, R);
13336 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
13337 IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
13339 switch (BO->getOpcode()) {
13341 llvm_unreachable(
"builtin <=> should have class type");
13352 return IntRange::forBoolType();
13370 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
13381 Combine = IntRange::bit_and;
13389 = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
13390 if (I->getValue() == 1) {
13391 IntRange R = IntRange::forValueOfType(
C,
GetExprType(E));
13392 return IntRange(R.Width,
true);
13402 case BO_ShrAssign: {
13403 IntRange L =
GetExprRange(
C, BO->getLHS(), MaxWidth, InConstantContext,
13408 if (std::optional<llvm::APSInt> shift =
13409 BO->getRHS()->getIntegerConstantExpr(
C)) {
13410 if (shift->isNonNegative()) {
13411 unsigned zext = shift->getZExtValue();
13412 if (zext >= L.Width)
13413 L.Width = (L.NonNegative ? 0 : 1);
13424 return GetExprRange(
C, BO->getRHS(), MaxWidth, InConstantContext,
13429 Combine = IntRange::sum;
13433 if (BO->getLHS()->getType()->isPointerType())
13436 Combine = IntRange::difference;
13441 Combine = IntRange::product;
13449 IntRange L =
GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext,
13453 if (std::optional<llvm::APSInt> divisor =
13454 BO->getRHS()->getIntegerConstantExpr(
C)) {
13455 unsigned log2 = divisor->logBase2();
13456 if (
log2 >= L.Width)
13457 L.Width = (L.NonNegative ? 0 : 1);
13459 L.Width = std::min(L.Width -
log2, MaxWidth);
13466 IntRange R =
GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext,
13468 return IntRange(L.Width, L.NonNegative && R.NonNegative);
13472 Combine = IntRange::rem;
13484 unsigned opWidth =
C.getIntWidth(T);
13486 GetExprRange(
C, BO->getLHS(), opWidth, InConstantContext, Approximate);
13488 GetExprRange(
C, BO->getRHS(), opWidth, InConstantContext, Approximate);
13489 IntRange
C = Combine(L, R);
13490 C.NonNegative |= T->isUnsignedIntegerOrEnumerationType();
13491 C.Width = std::min(
C.Width, MaxWidth);
13495 if (
const auto *UO = dyn_cast<UnaryOperator>(E)) {
13496 switch (UO->getOpcode()) {
13499 return IntRange::forBoolType();
13507 return GetExprRange(
C, UO->getSubExpr(), MaxWidth, InConstantContext,
13512 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
13513 return GetExprRange(
C, OVE->getSourceExpr(), MaxWidth, InConstantContext,
13517 return IntRange(BitField->getBitWidthValue(
C),
13518 BitField->getType()->isUnsignedIntegerOrEnumerationType());
13524 bool InConstantContext,
bool Approximate) {
13533 const llvm::fltSemantics &Src,
13534 const llvm::fltSemantics &Tgt) {
13535 llvm::APFloat truncated = value;
13538 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
13539 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
13541 return truncated.bitwiseIsEqual(value);
13550 const llvm::fltSemantics &Src,
13551 const llvm::fltSemantics &Tgt) {
13568 bool IsListInit =
false);
13574 if (isa<EnumConstantDecl>(DR->getDecl()))
13584 return MacroName !=
"YES" && MacroName !=
"NO" &&
13585 MacroName !=
"true" && MacroName !=
"false";
13593 (!E->
getType()->isSignedIntegerType() ||
13608struct PromotedRange {
13610 llvm::APSInt PromotedMin;
13612 llvm::APSInt PromotedMax;
13614 PromotedRange(IntRange R,
unsigned BitWidth,
bool Unsigned) {
13616 PromotedMin = PromotedMax = llvm::APSInt(BitWidth,
Unsigned);
13617 else if (R.Width >= BitWidth && !
Unsigned) {
13621 PromotedMin = llvm::APSInt::getMinValue(BitWidth,
Unsigned);
13622 PromotedMax = llvm::APSInt::getMaxValue(BitWidth,
Unsigned);
13624 PromotedMin = llvm::APSInt::getMinValue(R.Width, R.NonNegative)
13625 .extOrTrunc(BitWidth);
13626 PromotedMin.setIsUnsigned(
Unsigned);
13628 PromotedMax = llvm::APSInt::getMaxValue(R.Width, R.NonNegative)
13629 .extOrTrunc(BitWidth);
13630 PromotedMax.setIsUnsigned(
Unsigned);
13635 bool isContiguous()
const {
return PromotedMin <= PromotedMax; }
13645 InRangeFlag = 0x40,
13648 Min =
LE | InRangeFlag,
13650 Max =
GE | InRangeFlag,
13653 OnlyValue =
LE |
GE |
EQ | InRangeFlag,
13658 assert(
Value.getBitWidth() == PromotedMin.getBitWidth() &&
13659 Value.isUnsigned() == PromotedMin.isUnsigned());
13660 if (!isContiguous()) {
13661 assert(
Value.isUnsigned() &&
"discontiguous range for signed compare");
13662 if (
Value.isMinValue())
return Min;
13663 if (
Value.isMaxValue())
return Max;
13669 switch (llvm::APSInt::compareValues(
Value, PromotedMin)) {
13670 case -1:
return Less;
13671 case 0:
return PromotedMin == PromotedMax ? OnlyValue : Min;
13673 switch (llvm::APSInt::compareValues(
Value, PromotedMax)) {
13675 case 0:
return Max;
13680 llvm_unreachable(
"impossible compare result");
13683 static std::optional<StringRef>
13685 if (Op == BO_Cmp) {
13687 if (ConstantOnRHS) std::swap(LTFlag, GTFlag);
13689 if (R & EQ)
return StringRef(
"'std::strong_ordering::equal'");
13690 if (R & LTFlag)
return StringRef(
"'std::strong_ordering::less'");
13691 if (R & GTFlag)
return StringRef(
"'std::strong_ordering::greater'");
13692 return std::nullopt;
13699 }
else if (Op == BO_NE) {
13703 if ((Op == BO_LT || Op == BO_GE) ^ ConstantOnRHS) {
13710 if (Op == BO_GE || Op == BO_LE)
13711 std::swap(TrueFlag, FalseFlag);
13714 return StringRef(
"true");
13716 return StringRef(
"false");
13717 return std::nullopt;
13725 if (ICE->getCastKind() != CK_IntegralCast &&
13726 ICE->getCastKind() != CK_NoOp)
13728 E = ICE->getSubExpr();
13737 enum ConstantValueKind {
13742 if (
auto *BL = dyn_cast<CXXBoolLiteralExpr>(Constant))
13743 return BL->getValue() ? ConstantValueKind::LiteralTrue
13744 : ConstantValueKind::LiteralFalse;
13745 return ConstantValueKind::Miscellaneous;
13750 const llvm::APSInt &
Value,
13751 bool RhsConstant) {
13755 Expr *OriginalOther = Other;
13758 Other = Other->IgnoreParenImpCasts();
13774 QualType OtherT = Other->getType();
13776 OtherT = AT->getValueType();
13777 IntRange OtherTypeRange = IntRange::forValueOfType(S.
Context, OtherT);
13781 bool IsObjCSignedCharBool = S.
getLangOpts().ObjC &&
13782 S.
NSAPIObj->isObjCBOOLType(OtherT) &&
13787 bool OtherIsBooleanDespiteType =
13788 !OtherT->
isBooleanType() && Other->isKnownToHaveBooleanValue();
13789 if (OtherIsBooleanDespiteType || IsObjCSignedCharBool)
13790 OtherTypeRange = OtherValueRange = IntRange::forBoolType();
13794 PromotedRange OtherPromotedValueRange(OtherValueRange,
Value.getBitWidth(),
13795 Value.isUnsigned());
13796 auto Cmp = OtherPromotedValueRange.compare(
Value);
13797 auto Result = PromotedRange::constantValue(E->
getOpcode(), Cmp, RhsConstant);
13803 bool TautologicalTypeCompare =
false;
13805 PromotedRange OtherPromotedTypeRange(OtherTypeRange,
Value.getBitWidth(),
13806 Value.isUnsigned());
13807 auto TypeCmp = OtherPromotedTypeRange.compare(
Value);
13810 TautologicalTypeCompare =
true;
13818 if (!TautologicalTypeCompare && OtherValueRange.Width == 0)
13827 bool InRange = Cmp & PromotedRange::InRangeFlag;
13833 if (Other->refersToBitField() && InRange &&
Value == 0 &&
13834 Other->getType()->isUnsignedIntegerOrEnumerationType())
13835 TautologicalTypeCompare =
true;
13840 if (
const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Constant))
13841 ED = dyn_cast<EnumConstantDecl>(DR->getDecl());
13845 llvm::raw_svector_ostream OS(PrettySourceValue);
13847 OS <<
'\'' << *ED <<
"' (" <<
Value <<
")";
13848 }
else if (
auto *BL = dyn_cast<ObjCBoolLiteralExpr>(
13850 OS << (BL->getValue() ?
"YES" :
"NO");
13855 if (!TautologicalTypeCompare) {
13857 << RhsConstant << OtherValueRange.Width << OtherValueRange.NonNegative
13863 if (IsObjCSignedCharBool) {
13865 S.
PDiag(diag::warn_tautological_compare_objc_bool)
13866 << OS.str() << *
Result);
13873 if (!InRange || Other->isKnownToHaveBooleanValue()) {
13877 S.
PDiag(!InRange ? diag::warn_out_of_range_compare
13878 : diag::warn_tautological_bool_compare)
13880 << OtherIsBooleanDespiteType << *
Result
13887 ? diag::warn_unsigned_enum_always_true_comparison
13888 : IsCharTy ? diag::warn_unsigned_char_always_true_comparison
13889 : diag::warn_unsigned_always_true_comparison)
13890 : diag::warn_tautological_constant_compare;
13926 if (T->isIntegralType(S.
Context)) {
13927 std::optional<llvm::APSInt> RHSValue =
13929 std::optional<llvm::APSInt> LHSValue =
13933 if (RHSValue && LHSValue)
13937 if ((
bool)RHSValue ^ (
bool)LHSValue) {
13939 const bool RhsConstant = (
bool)RHSValue;
13940 Expr *Const = RhsConstant ? RHS : LHS;
13941 Expr *Other = RhsConstant ? LHS : RHS;
13942 const llvm::APSInt &
Value = RhsConstant ? *RHSValue : *LHSValue;
13951 if (!T->hasUnsignedIntegerRepresentation()) {
13965 if (
const auto *TET = dyn_cast<TypeOfExprType>(LHS->
getType()))
13967 if (
const auto *TET = dyn_cast<TypeOfExprType>(RHS->
getType()))
13973 Expr *signedOperand, *unsignedOperand;
13976 "unsigned comparison between two signed integer expressions?");
13977 signedOperand = LHS;
13978 unsignedOperand = RHS;
13980 signedOperand = RHS;
13981 unsignedOperand = LHS;
13996 if (signedRange.NonNegative)
14005 IntRange unsignedRange =
14011 assert(unsignedRange.NonNegative &&
"unsigned range includes negative?");
14013 if (unsignedRange.Width < comparisonWidth)
14018 S.
PDiag(diag::warn_mixed_sign_comparison)
14038 EnumDecl *BitfieldEnumDecl = BitfieldType->
castAs<EnumType>()->getDecl();
14046 S.
Diag(InitLoc, diag::warn_no_underlying_type_specified_for_enum_bitfield)
14047 << BitfieldEnumDecl;
14054 Init->isValueDependent() ||
14055 Init->isTypeDependent())
14058 Expr *OriginalInit = Init->IgnoreParenImpCasts();
14067 if (
const auto *EnumTy = OriginalInit->
getType()->
getAs<EnumType>()) {
14081 unsigned DiagID = 0;
14082 if (SignedEnum && !SignedBitfield) {
14083 DiagID = diag::warn_unsigned_bitfield_assigned_signed_enum;
14084 }
else if (SignedBitfield && !SignedEnum &&
14086 DiagID = diag::warn_signed_bitfield_enum_conversion;
14090 S.
Diag(InitLoc, DiagID) << Bitfield << ED;
14095 << SignedEnum << TypeRange;
14106 if (BitsNeeded > FieldWidth) {
14108 S.
Diag(InitLoc, diag::warn_bitfield_too_small_for_enum)
14120 unsigned OriginalWidth =
Value.getBitWidth();
14126 bool OneAssignedToOneBitBitfield = FieldWidth == 1 &&
Value == 1;
14127 if (OneAssignedToOneBitBitfield && !S.
LangOpts.CPlusPlus) {
14134 if (!
Value.isSigned() ||
Value.isNegative())
14135 if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(OriginalInit))
14136 if (UO->getOpcode() == UO_Minus || UO->getOpcode() == UO_Not)
14137 OriginalWidth =
Value.getSignificantBits();
14139 if (OriginalWidth <= FieldWidth)
14143 llvm::APSInt TruncatedValue =
Value.trunc(FieldWidth);
14147 TruncatedValue = TruncatedValue.extend(OriginalWidth);
14148 if (llvm::APSInt::isSameValue(
Value, TruncatedValue))
14152 std::string PrettyTrunc =
toString(TruncatedValue, 10);
14154 S.
Diag(InitLoc, OneAssignedToOneBitBitfield
14155 ? diag::warn_impcast_single_bit_bitield_precision_constant
14156 : diag::warn_impcast_bitfield_precision_constant)
14157 << PrettyValue << PrettyTrunc << OriginalInit->
getType()
14158 << Init->getSourceRange();
14190 bool pruneControlFlow =
false) {
14191 if (pruneControlFlow) {
14205 unsigned diag,
bool pruneControlFlow =
false) {
14217 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
14218 Ignored = OVE->getSourceExpr();
14232 const bool IsBool = T->isSpecificBuiltinType(BuiltinType::Bool);
14238 if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
14241 const bool IsLiteral =
14244 llvm::APFloat
Value(0.0);
14251 S.
Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
14256 diag::warn_impcast_float_integer, PruneWarnings);
14259 bool isExact =
false;
14262 T->hasUnsignedIntegerRepresentation());
14263 llvm::APFloat::opStatus
Result =
Value.convertToInteger(
14264 IntegerValue, llvm::APFloat::rmTowardZero, &isExact);
14272 unsigned precision = llvm::APFloat::semanticsPrecision(
Value.getSemantics());
14273 precision = (precision * 59 + 195) / 196;
14274 Value.toString(PrettySourceValue, precision);
14279 S.
Diag(CContext, diag::warn_impcast_constant_value_to_objc_bool)
14280 << PrettySourceValue);
14283 if (
Result == llvm::APFloat::opOK && isExact) {
14284 if (IsLiteral)
return;
14285 return DiagnoseImpCast(S, E, T, CContext, diag::warn_impcast_float_integer,
14291 if (!IsBool &&
Result == llvm::APFloat::opInvalidOp)
14294 IsLiteral ? diag::warn_impcast_literal_float_to_integer_out_of_range
14295 : diag::warn_impcast_float_to_integer_out_of_range,
14298 unsigned DiagID = 0;
14301 DiagID = diag::warn_impcast_literal_float_to_integer;
14302 }
else if (IntegerValue == 0) {
14303 if (
Value.isZero()) {
14305 diag::warn_impcast_float_integer, PruneWarnings);
14308 DiagID = diag::warn_impcast_float_to_integer_zero;
14310 if (IntegerValue.isUnsigned()) {
14311 if (!IntegerValue.isMaxValue()) {
14313 diag::warn_impcast_float_integer, PruneWarnings);
14316 if (!IntegerValue.isMaxSignedValue() &&
14317 !IntegerValue.isMinSignedValue()) {
14319 diag::warn_impcast_float_integer, PruneWarnings);
14323 DiagID = diag::warn_impcast_float_to_integer;
14328 PrettyTargetValue =
Value.isZero() ?
"false" :
"true";
14330 IntegerValue.toString(PrettyTargetValue);
14332 if (PruneWarnings) {
14336 << PrettySourceValue << PrettyTargetValue
14348 assert(isa<CompoundAssignOperator>(E) &&
14349 "Must be compound assignment operation");
14360 ->getComputationResultType()
14367 if (ResultBT->isInteger())
14369 E->
getExprLoc(), diag::warn_impcast_float_integer);
14371 if (!ResultBT->isFloatingPoint())
14380 diag::warn_impcast_float_result_precision);
14385 if (!Range.Width)
return "0";
14387 llvm::APSInt ValueInRange =
Value;
14388 ValueInRange.setIsSigned(!Range.NonNegative);
14389 ValueInRange = ValueInRange.trunc(Range.Width);
14390 return toString(ValueInRange, 10);
14394 if (!isa<ImplicitCastExpr>(Ex))
14399 const Type *Source =
14401 if (Target->isDependentType())
14405 dyn_cast<BuiltinType>(ToBool ? Source : Target);
14406 const Type *BoolCandidateType = ToBool ?
Target : Source;
14415 for (
unsigned i = 0; i < NumArgs; ++i) {
14420 bool IsSwapped = ((i > 0) &&
14422 IsSwapped |= ((i < (NumArgs - 1)) &&
14428 diag::warn_impcast_floating_point_to_bool);
14435 if (S.
Diags.
isIgnored(diag::warn_impcast_null_pointer_to_integer,
14440 if (isa<CallExpr>(E))
14447 if (!IsGNUNullExpr && !HasNullPtrType)
14451 if (T->isAnyPointerType() || T->isBlockPointerType() ||
14452 T->isMemberPointerType() || !T->isScalarType() || T->isNullPtrType())
14464 if (IsGNUNullExpr && Loc.isMacroID()) {
14467 if (MacroName ==
"NULL")
14475 S.
Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
14493 unsigned ElementKind) {
14495 if (
auto ICE = dyn_cast<ImplicitCastExpr>(Element)) {
14496 if (ICE->getCastKind() == CK_BitCast &&
14498 Element = ICE->getSubExpr();
14501 QualType ElementType = Element->getType();
14508 S.
Diag(Element->getBeginLoc(), diag::warn_objc_collection_literal_element)
14509 << ElementType << ElementKind << TargetElementType
14510 << Element->getSourceRange();
14513 if (
auto ArrayLiteral = dyn_cast<ObjCArrayLiteral>(Element))
14515 else if (
auto DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(Element))
14527 if (!TargetObjCPtr)
14530 if (TargetObjCPtr->isUnspecialized() ||
14531 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
14536 if (TypeArgs.size() != 1)
14539 QualType TargetElementType = TypeArgs[0];
14556 if (!TargetObjCPtr)
14559 if (TargetObjCPtr->isUnspecialized() ||
14560 TargetObjCPtr->getInterfaceDecl()->getCanonicalDecl()
14565 if (TypeArgs.size() != 2)
14568 QualType TargetKeyType = TypeArgs[0];
14569 QualType TargetObjectType = TypeArgs[1];
14570 for (
unsigned I = 0,
N = DictionaryLiteral->
getNumElements(); I !=
N; ++I) {
14585 const char FirstLiteralCharacter =
14587 if (FirstLiteralCharacter ==
'0')
14593 if (CC.
isValid() && T->isCharType()) {
14594 const char FirstContextCharacter =
14596 if (FirstContextCharacter ==
'{')
14604 const auto *IL = dyn_cast<IntegerLiteral>(E);
14606 if (
auto *UO = dyn_cast<UnaryOperator>(E)) {
14607 if (UO->getOpcode() == UO_Minus)
14608 return dyn_cast<IntegerLiteral>(UO->getSubExpr());
14619 if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
14623 if (Opc == BO_Shl) {
14626 if (LHS && LHS->getValue() == 0)
14627 S.
Diag(ExprLoc, diag::warn_left_shift_always) << 0;
14629 RHS->getValue().isNonNegative() &&
14631 S.
Diag(ExprLoc, diag::warn_left_shift_always)
14632 << (
Result.Val.getInt() != 0);
14634 S.
Diag(ExprLoc, diag::warn_left_shift_in_bool_context) << E;
14638 if (
const auto *CO = dyn_cast<ConditionalOperator>(E)) {
14643 if ((LHS->getValue() == 0 || LHS->getValue() == 1) &&
14644 (RHS->getValue() == 0 || RHS->getValue() == 1))
14647 if (LHS->getValue() != 0 && RHS->getValue() != 0)
14648 S.
Diag(ExprLoc, diag::warn_integer_constants_in_conditional_always_true);
14654 bool *ICContext =
nullptr,
14655 bool IsListInit =
false) {
14660 if (Source == Target)
return;
14661 if (Target->isDependentType())
return;
14671 if (Source->isAtomicType())
14675 if (Target->isSpecificBuiltinType(BuiltinType::Bool)) {
14676 if (isa<StringLiteral>(E))
14681 diag::warn_impcast_string_literal_to_bool);
14682 if (isa<ObjCStringLiteral>(E) || isa<ObjCArrayLiteral>(E) ||
14683 isa<ObjCDictionaryLiteral>(E) || isa<ObjCBoxedExpr>(E)) {
14687 diag::warn_impcast_objective_c_literal_to_bool);
14689 if (Source->isPointerType() || Source->canDecayToPointerType()) {
14703 if (
Result.Val.getInt() != 1 &&
Result.Val.getInt() != 0) {
14706 S.
Diag(CC, diag::warn_impcast_constant_value_to_objc_bool)
14715 if (
auto *ArrayLiteral = dyn_cast<ObjCArrayLiteral>(E))
14717 else if (
auto *DictionaryLiteral = dyn_cast<ObjCDictionaryLiteral>(E))
14721 if (isa<VectorType>(Source)) {
14722 if (Target->isVLSTBuiltinType() &&
14729 if (Target->isRVVVLSBuiltinType() &&
14736 if (!isa<VectorType>(Target)) {
14739 return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_vector_scalar);
14750 if (
auto VecTy = dyn_cast<VectorType>(Target))
14751 Target = VecTy->getElementType().getTypePtr();
14754 if (isa<ComplexType>(Source)) {
14755 if (!isa<ComplexType>(Target)) {
14761 ? diag::err_impcast_complex_scalar
14762 : diag::warn_impcast_complex_scalar);
14769 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
14770 const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
14821 else if (Order < 0) {
14831 if (TargetBT && TargetBT->
isInteger()) {
14846 if (Target->isBooleanType() && isa<CallExpr>(E)) {
14854 if (isa<ImplicitCastExpr>(LastA) &&
14858 diag::warn_impcast_floating_point_to_bool);
14866 if (Source->isFixedPointType()) {
14867 if (Target->isUnsaturatedFixedPointType()) {
14871 llvm::APFixedPoint
Value =
Result.Val.getFixedPoint();
14876 S.
PDiag(diag::warn_impcast_fixed_point_range)
14877 <<
Value.toString() << T
14883 }
else if (Target->isIntegerType()) {
14888 llvm::APFixedPoint FXResult =
Result.Val.getFixedPoint();
14891 llvm::APSInt IntResult = FXResult.convertToInt(
14893 Target->isSignedIntegerOrEnumerationType(), &Overflowed);
14897 S.
PDiag(diag::warn_impcast_fixed_point_range)
14898 << FXResult.toString() << T
14905 }
else if (Target->isUnsaturatedFixedPointType()) {
14906 if (Source->isIntegerType()) {
14913 llvm::APFixedPoint IntResult = llvm::APFixedPoint::getFromIntValue(
14918 S.
PDiag(diag::warn_impcast_fixed_point_range)
14936 unsigned int SourcePrecision =
SourceRange.Width;
14940 unsigned int TargetPrecision = llvm::APFloatBase::semanticsPrecision(
14943 if (SourcePrecision > 0 && TargetPrecision > 0 &&
14944 SourcePrecision > TargetPrecision) {
14946 if (std::optional<llvm::APSInt> SourceInt =
14951 llvm::APFloat TargetFloatValue(
14953 llvm::APFloat::opStatus ConversionStatus =
14954 TargetFloatValue.convertFromAPInt(
14956 llvm::APFloat::rmNearestTiesToEven);
14958 if (ConversionStatus != llvm::APFloat::opOK) {
14960 SourceInt->toString(PrettySourceValue, 10);
14962 TargetFloatValue.toString(PrettyTargetValue, TargetPrecision);
14966 S.
PDiag(diag::warn_impcast_integer_float_precision_constant)
14967 << PrettySourceValue << PrettyTargetValue << E->
getType() << T
14973 diag::warn_impcast_integer_float_precision);
14982 if (Target->isBooleanType())
14985 if (!Source->isIntegerType() || !Target->isIntegerType())
14990 if (Target->isSpecificBuiltinType(BuiltinType::Bool))
14997 S.
Diag(CC, diag::warn_impcast_int_to_objc_signed_char_bool)
15001 IntRange SourceTypeRange =
15002 IntRange::forTargetOfCanonicalType(S.
Context, Source);
15003 IntRange LikelySourceRange =
15005 IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.
Context, Target);
15007 if (LikelySourceRange.Width > TargetRange.Width) {
15013 llvm::APSInt
Value(32);
15024 S.
PDiag(diag::warn_impcast_integer_precision_constant)
15025 << PrettySourceValue << PrettyTargetValue << E->
getType() << T
15035 return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_integer_64_32,
15037 return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_integer_precision);
15040 if (TargetRange.Width > SourceTypeRange.Width) {
15041 if (
auto *UO = dyn_cast<UnaryOperator>(E))
15042 if (UO->getOpcode() == UO_Minus)
15043 if (Source->isUnsignedIntegerType()) {
15044 if (Target->isUnsignedIntegerType())
15046 diag::warn_impcast_high_order_zero_bits);
15047 if (Target->isSignedIntegerType())
15049 diag::warn_impcast_nonnegative_result);
15053 if (TargetRange.Width == LikelySourceRange.Width &&
15054 !TargetRange.NonNegative && LikelySourceRange.NonNegative &&
15055 Source->isSignedIntegerType()) {
15070 S.
PDiag(diag::warn_impcast_integer_precision_constant)
15071 << PrettySourceValue << PrettyTargetValue << E->
getType() << T
15080 if ((!isa<EnumType>(Target) || !isa<EnumType>(Source)) &&
15081 ((TargetRange.NonNegative && !LikelySourceRange.NonNegative) ||
15082 (!TargetRange.NonNegative && LikelySourceRange.NonNegative &&
15083 LikelySourceRange.Width == TargetRange.Width))) {
15087 if (SourceBT && SourceBT->
isInteger() && TargetBT &&
15089 Source->isSignedIntegerType() == Target->isSignedIntegerType()) {
15093 unsigned DiagID = diag::warn_impcast_integer_sign;
15101 DiagID = diag::warn_impcast_integer_sign_conditional;
15121 if (
const EnumType *SourceEnum = Source->getAs<EnumType>())
15122 if (
const EnumType *TargetEnum = Target->getAs<EnumType>())
15123 if (SourceEnum->getDecl()->hasNameForLinkage() &&
15124 TargetEnum->getDecl()->hasNameForLinkage() &&
15125 SourceEnum != TargetEnum) {
15130 diag::warn_impcast_different_enum_types);
15144 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(E))
15157 if (
auto *BCO = dyn_cast<BinaryConditionalOperator>(E))
15158 TrueExpr = BCO->getCommon();
15160 bool Suspicious =
false;
15164 if (T->isBooleanType())
15169 if (!Suspicious)
return;
15172 if (!S.
Diags.
isIgnored(diag::warn_impcast_integer_sign_conditional, CC))
15177 if (E->
getType() == T)
return;
15179 Suspicious =
false;
15181 E->
getType(), CC, &Suspicious);
15184 E->
getType(), CC, &Suspicious);
15198struct AnalyzeImplicitConversionsWorkItem {
15208 Sema &S, AnalyzeImplicitConversionsWorkItem Item,
15210 Expr *OrigE = Item.E;
15219 bool IsListInit = Item.IsListInit ||
15225 Expr *SourceExpr = E;
15230 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(E))
15231 if (
auto *Src = OVE->getSourceExpr())
15234 if (
const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))
15235 if (UO->getOpcode() == UO_Not &&
15236 UO->getSubExpr()->isKnownToHaveBooleanValue())
15237 S.
Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool)
15241 if (
const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
15242 if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
15243 BO->getLHS()->isKnownToHaveBooleanValue() &&
15244 BO->getRHS()->isKnownToHaveBooleanValue() &&
15245 BO->getLHS()->HasSideEffects(S.
Context) &&
15246 BO->getRHS()->HasSideEffects(S.
Context)) {
15247 S.
Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical)
15248 << (BO->getOpcode() == BO_And ?
"&" :
"|") << OrigE->
getSourceRange()
15250 BO->getOperatorLoc(),
15251 (BO->getOpcode() == BO_And ?
"&&" :
"||"));
15252 S.
Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
15257 if (
auto *CO = dyn_cast<AbstractConditionalOperator>(SourceExpr)) {
15263 if (
CallExpr *Call = dyn_cast<CallExpr>(SourceExpr))
15269 if (SourceExpr->
getType() != T)
15278 for (
auto *SE : POE->semantics())
15279 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(SE))
15280 WorkList.push_back({OVE->getSourceExpr(), CC, IsListInit});
15284 if (
auto *CE = dyn_cast<ExplicitCastExpr>(E)) {
15288 WorkList.push_back({E, CC, IsListInit});
15294 if (BO->isComparisonOp())
15298 if (BO->getOpcode() == BO_Assign)
15301 if (BO->isAssignmentOp())
15309 if (isa<StmtExpr>(E))
return;
15312 if (isa<UnaryExprOrTypeTraitExpr>(E))
return;
15317 bool IsLogicalAndOperator = BO && BO->
getOpcode() == BO_LAnd;
15319 Expr *ChildExpr = dyn_cast_or_null<Expr>(SubStmt);
15323 if (
auto *CSE = dyn_cast<CoroutineSuspendExpr>(E))
15324 if (ChildExpr == CSE->getOperand())
15330 if (IsLogicalAndOperator &&
15335 WorkList.push_back({ChildExpr, CC, IsListInit});
15340 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
15344 if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
15349 if (
U->getOpcode() == UO_LNot) {
15351 }
else if (
U->getOpcode() != UO_AddrOf) {
15352 if (
U->getSubExpr()->getType()->isAtomicType())
15353 S.
Diag(
U->getSubExpr()->getBeginLoc(),
15354 diag::warn_atomic_implicit_seq_cst);
15365 WorkList.push_back({OrigE, CC, IsListInit});
15366 while (!WorkList.empty())
15376 diag::err_opencl_enqueue_kernel_invalid_local_size_type);
15393 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
15396 }
else if (
const MemberExpr *M = dyn_cast<MemberExpr>(E)) {
15397 if (!M->getMemberDecl()->getType()->isReferenceType())
15399 }
else if (
const CallExpr *Call = dyn_cast<CallExpr>(E)) {
15400 if (!Call->getCallReturnType(SemaRef.
Context)->isReferenceType())
15402 FD = Call->getDirectCallee();
15411 SemaRef.
Diag(FD->
getLocation(), diag::note_reference_is_return_value) << FD;
15421 if (Loc.isInvalid())
15424 while (Loc.isMacroID()) {
15425 if (
SM.isMacroBodyExpansion(Loc))
15427 Loc =
SM.getImmediateMacroCallerLoc(Loc);
15456 if (isa<CXXThisExpr>(E)) {
15457 unsigned DiagID = IsCompare ? diag::warn_this_null_compare
15458 : diag::warn_this_bool_conversion;
15463 bool IsAddressOf =
false;
15465 if (
auto *UO = dyn_cast<UnaryOperator>(E->
IgnoreParens())) {
15466 if (UO->getOpcode() != UO_AddrOf)
15468 IsAddressOf =
true;
15469 E = UO->getSubExpr();
15473 unsigned DiagID = IsCompare
15474 ? diag::warn_address_of_reference_null_compare
15475 : diag::warn_address_of_reference_bool_conversion;
15483 auto ComplainAboutNonnullParamOrCall = [&](
const Attr *NonnullAttr) {
15486 llvm::raw_string_ostream S(Str);
15488 unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare
15489 : diag::warn_cast_nonnull_to_bool;
15492 Diag(NonnullAttr->getLocation(), diag::note_declared_nonnull) << IsParam;
15497 if (
auto *Callee = Call->getDirectCallee()) {
15498 if (
const Attr *A = Callee->getAttr<ReturnsNonNullAttr>()) {
15499 ComplainAboutNonnullParamOrCall(A);
15509 }
else if (
MemberExpr *M = dyn_cast<MemberExpr>(E)) {
15510 D = M->getMemberDecl();
15518 if (
const auto* PV = dyn_cast<ParmVarDecl>(D)) {
15521 if (
const Attr *A = PV->getAttr<NonNullAttr>()) {
15522 ComplainAboutNonnullParamOrCall(A);
15526 if (
const auto *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
15530 auto ParamIter = llvm::find(FD->
parameters(), PV);
15532 unsigned ParamNo = std::distance(FD->
param_begin(), ParamIter);
15536 ComplainAboutNonnullParamOrCall(
NonNull);
15541 if (ArgNo.getASTIndex() == ParamNo) {
15542 ComplainAboutNonnullParamOrCall(
NonNull);
15553 const bool IsFunction = T->isFunctionType();
15556 if (IsAddressOf && IsFunction) {
15561 if (!IsAddressOf && !IsFunction && !IsArray)
15566 llvm::raw_string_ostream S(Str);
15569 unsigned DiagID = IsCompare ? diag::warn_null_pointer_compare
15570 : diag::warn_impcast_pointer_to_bool;
15577 DiagType = AddressOf;
15578 else if (IsFunction)
15579 DiagType = FunctionPointer;
15581 DiagType = ArrayPointer;
15583 llvm_unreachable(
"Could not determine diagnostic.");
15585 << Range << IsEqual;
15598 if (ReturnType.
isNull())
15643 CheckArrayAccess(E);
15652 ::CheckBoolLikeConversion(*
this, E, CC);
15657void Sema::CheckForIntOverflow (
const Expr *E) {
15662 const Expr *OriginalE = Exprs.pop_back_val();
15665 if (isa<BinaryOperator, UnaryOperator>(E)) {
15670 if (
const auto *InitList = dyn_cast<InitListExpr>(OriginalE))
15671 Exprs.append(InitList->inits().begin(), InitList->inits().end());
15672 else if (isa<ObjCBoxedExpr>(OriginalE))
15674 else if (
const auto *Call = dyn_cast<CallExpr>(E))
15675 Exprs.append(
Call->arg_begin(),
Call->arg_end());
15676 else if (
const auto *Message = dyn_cast<ObjCMessageExpr>(E))
15677 Exprs.append(Message->arg_begin(), Message->arg_end());
15678 else if (
const auto *Construct = dyn_cast<CXXConstructExpr>(E))
15679 Exprs.append(Construct->arg_begin(), Construct->arg_end());
15680 else if (
const auto *Temporary = dyn_cast<CXXBindTemporaryExpr>(E))
15681 Exprs.push_back(Temporary->getSubExpr());
15682 else if (
const auto *Array = dyn_cast<ArraySubscriptExpr>(E))
15683 Exprs.push_back(Array->getIdx());
15684 else if (
const auto *Compound = dyn_cast<CompoundLiteralExpr>(E))
15685 Exprs.push_back(Compound->getInitializer());
15686 else if (
const auto *New = dyn_cast<CXXNewExpr>(E);
15687 New && New->isArray()) {
15688 if (
auto ArraySize = New->getArraySize())
15689 Exprs.push_back(*ArraySize);
15691 }
while (!Exprs.empty());
15706 class SequenceTree {
15710 unsigned Merged : 1;
15718 friend class SequenceTree;
15722 explicit Seq(
unsigned N) : Index(
N) {}
15725 Seq() : Index(0) {}
15728 SequenceTree() { Values.push_back(
Value(0)); }
15729 Seq root()
const {
return Seq(0); }
15734 Seq allocate(Seq
Parent) {
15736 return Seq(Values.size() - 1);
15740 void merge(Seq S) {
15741 Values[S.Index].Merged =
true;
15747 bool isUnsequenced(Seq Cur, Seq Old) {
15748 unsigned C = representative(Cur.Index);
15749 unsigned Target = representative(Old.Index);
15750 while (
C >= Target) {
15753 C = Values[
C].Parent;
15760 unsigned representative(
unsigned K) {
15761 if (Values[K].Merged)
15763 return Values[K].Parent = representative(Values[K].
Parent);
15783 UK_ModAsSideEffect,
15785 UK_Count = UK_ModAsSideEffect + 1
15791 const Expr *UsageExpr;
15792 SequenceTree::Seq Seq;
15794 Usage() : UsageExpr(nullptr) {}
15798 Usage Uses[UK_Count];
15803 UsageInfo() : Diagnosed(
false) {}
15805 using UsageInfoMap = llvm::SmallDenseMap<Object, UsageInfo, 16>;
15813 UsageInfoMap UsageMap;
15816 SequenceTree::Seq Region;
15831 struct SequencedSubexpression {
15832 SequencedSubexpression(SequenceChecker &Self)
15833 : Self(Self), OldModAsSideEffect(Self.ModAsSideEffect) {
15834 Self.ModAsSideEffect = &ModAsSideEffect;
15837 ~SequencedSubexpression() {
15838 for (
const std::pair<Object, Usage> &M : llvm::reverse(ModAsSideEffect)) {
15842 UsageInfo &UI = Self.UsageMap[M.first];
15843 auto &SideEffectUsage = UI.Uses[UK_ModAsSideEffect];
15844 Self.addUsage(M.first, UI, SideEffectUsage.UsageExpr, UK_ModAsValue);
15845 SideEffectUsage = M.second;
15847 Self.ModAsSideEffect = OldModAsSideEffect;
15850 SequenceChecker &Self;
15859 class EvaluationTracker {
15861 EvaluationTracker(SequenceChecker &Self)
15862 : Self(Self), Prev(Self.EvalTracker) {
15863 Self.EvalTracker =
this;
15866 ~EvaluationTracker() {
15867 Self.EvalTracker = Prev;
15869 Prev->EvalOK &= EvalOK;
15872 bool evaluate(
const Expr *E,
bool &Result) {
15876 Result, Self.SemaRef.Context, Self.SemaRef.isConstantEvaluated());
15881 SequenceChecker &Self;
15882 EvaluationTracker *Prev;
15883 bool EvalOK =
true;
15884 } *EvalTracker =
nullptr;
15888 Object getObject(
const Expr *E,
bool Mod)
const {
15890 if (
const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
15891 if (Mod && (UO->getOpcode() == UO_PreInc || UO->getOpcode() == UO_PreDec))
15892 return getObject(UO->getSubExpr(), Mod);
15893 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
15894 if (BO->getOpcode() == BO_Comma)
15895 return getObject(BO->getRHS(), Mod);
15896 if (Mod && BO->isAssignmentOp())
15897 return getObject(BO->getLHS(), Mod);
15898 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
15900 if (isa<CXXThisExpr>(ME->getBase()->IgnoreParenCasts()))
15901 return ME->getMemberDecl();
15902 }
else if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
15911 void addUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr, UsageKind UK) {
15913 Usage &
U = UI.Uses[UK];
15914 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq)) {
15918 if (UK == UK_ModAsSideEffect && ModAsSideEffect)
15919 ModAsSideEffect->push_back(std::make_pair(O,
U));
15921 U.UsageExpr = UsageExpr;
15931 void checkUsage(Object O, UsageInfo &UI,
const Expr *UsageExpr,
15932 UsageKind OtherKind,
bool IsModMod) {
15936 const Usage &
U = UI.Uses[OtherKind];
15937 if (!
U.UsageExpr || !
Tree.isUnsequenced(Region,
U.Seq))
15940 const Expr *Mod =
U.UsageExpr;
15941 const Expr *ModOrUse = UsageExpr;
15942 if (OtherKind == UK_Use)
15943 std::swap(Mod, ModOrUse);
15947 SemaRef.
PDiag(IsModMod ? diag::warn_unsequenced_mod_mod
15948 : diag::warn_unsequenced_mod_use)
15950 UI.Diagnosed =
true;
15979 void notePreUse(Object O,
const Expr *UseExpr) {
15980 UsageInfo &UI = UsageMap[O];
15982 checkUsage(O, UI, UseExpr, UK_ModAsValue,
false);
15985 void notePostUse(Object O,
const Expr *UseExpr) {
15986 UsageInfo &UI = UsageMap[O];
15987 checkUsage(O, UI, UseExpr, UK_ModAsSideEffect,
15989 addUsage(O, UI, UseExpr, UK_Use);
15992 void notePreMod(Object O,
const Expr *ModExpr) {
15993 UsageInfo &UI = UsageMap[O];
15995 checkUsage(O, UI, ModExpr, UK_ModAsValue,
true);
15996 checkUsage(O, UI, ModExpr, UK_Use,
false);
15999 void notePostMod(Object O,
const Expr *ModExpr, UsageKind UK) {
16000 UsageInfo &UI = UsageMap[O];
16001 checkUsage(O, UI, ModExpr, UK_ModAsSideEffect,
16003 addUsage(O, UI, ModExpr, UK);
16007 SequenceChecker(
Sema &S,
const Expr *E,
16009 :
Base(S.Context), SemaRef(S), Region(
Tree.root()), WorkList(WorkList) {
16013 (void)this->WorkList;
16016 void VisitStmt(
const Stmt *S) {
16020 void VisitExpr(
const Expr *E) {
16022 Base::VisitStmt(E);
16026 for (
auto *Sub : CSE->
children()) {
16027 const Expr *ChildExpr = dyn_cast_or_null<Expr>(Sub);
16042 void VisitCastExpr(
const CastExpr *E) {
16054 void VisitSequencedExpressions(
const Expr *SequencedBefore,
16055 const Expr *SequencedAfter) {
16056 SequenceTree::Seq BeforeRegion =
Tree.allocate(Region);
16057 SequenceTree::Seq AfterRegion =
Tree.allocate(Region);
16058 SequenceTree::Seq OldRegion = Region;
16061 SequencedSubexpression SeqBefore(*
this);
16062 Region = BeforeRegion;
16063 Visit(SequencedBefore);
16066 Region = AfterRegion;
16067 Visit(SequencedAfter);
16069 Region = OldRegion;
16071 Tree.merge(BeforeRegion);
16072 Tree.merge(AfterRegion);
16080 VisitSequencedExpressions(ASE->
getLHS(), ASE->
getRHS());
16087 void VisitBinPtrMemD(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
16088 void VisitBinPtrMemI(
const BinaryOperator *BO) { VisitBinPtrMem(BO); }
16094 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
16101 void VisitBinShl(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
16102 void VisitBinShr(
const BinaryOperator *BO) { VisitBinShlShr(BO); }
16107 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
16119 VisitSequencedExpressions(BO->
getLHS(), BO->
getRHS());
16123 SequenceTree::Seq RHSRegion;
16124 SequenceTree::Seq LHSRegion;
16126 RHSRegion =
Tree.allocate(Region);
16127 LHSRegion =
Tree.allocate(Region);
16129 RHSRegion = Region;
16130 LHSRegion = Region;
16132 SequenceTree::Seq OldRegion = Region;
16148 SequencedSubexpression SeqBefore(*
this);
16149 Region = RHSRegion;
16153 Region = LHSRegion;
16156 if (O && isa<CompoundAssignOperator>(BO))
16157 notePostUse(O, BO);
16161 Region = LHSRegion;
16164 if (O && isa<CompoundAssignOperator>(BO))
16165 notePostUse(O, BO);
16167 Region = RHSRegion;
16175 Region = OldRegion;
16179 : UK_ModAsSideEffect);
16181 Tree.merge(RHSRegion);
16182 Tree.merge(LHSRegion);
16187 VisitBinAssign(CAO);
16190 void VisitUnaryPreInc(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
16191 void VisitUnaryPreDec(
const UnaryOperator *UO) { VisitUnaryPreIncDec(UO); }
16195 return VisitExpr(UO);
16203 : UK_ModAsSideEffect);
16206 void VisitUnaryPostInc(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
16207 void VisitUnaryPostDec(
const UnaryOperator *UO) { VisitUnaryPostIncDec(UO); }
16211 return VisitExpr(UO);
16215 notePostMod(O, UO, UK_ModAsSideEffect);
16224 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
16225 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
16226 SequenceTree::Seq OldRegion = Region;
16228 EvaluationTracker Eval(*
this);
16230 SequencedSubexpression Sequenced(*
this);
16231 Region = LHSRegion;
16238 bool EvalResult =
false;
16239 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
16240 bool ShouldVisitRHS = !EvalOK || (EvalOK && !EvalResult);
16241 if (ShouldVisitRHS) {
16242 Region = RHSRegion;
16246 Region = OldRegion;
16247 Tree.merge(LHSRegion);
16248 Tree.merge(RHSRegion);
16257 SequenceTree::Seq LHSRegion =
Tree.allocate(Region);
16258 SequenceTree::Seq RHSRegion =
Tree.allocate(Region);
16259 SequenceTree::Seq OldRegion = Region;
16261 EvaluationTracker Eval(*
this);
16263 SequencedSubexpression Sequenced(*
this);
16264 Region = LHSRegion;
16270 bool EvalResult =
false;
16271 bool EvalOK = Eval.evaluate(BO->
getLHS(), EvalResult);
16272 bool ShouldVisitRHS = !EvalOK || (EvalOK && EvalResult);
16273 if (ShouldVisitRHS) {
16274 Region = RHSRegion;
16278 Region = OldRegion;
16279 Tree.merge(LHSRegion);
16280 Tree.merge(RHSRegion);
16288 SequenceTree::Seq ConditionRegion =
Tree.allocate(Region);
16304 SequenceTree::Seq TrueRegion =
Tree.allocate(Region);
16305 SequenceTree::Seq FalseRegion =
Tree.allocate(Region);
16306 SequenceTree::Seq OldRegion = Region;
16308 EvaluationTracker Eval(*
this);
16310 SequencedSubexpression Sequenced(*
this);
16311 Region = ConditionRegion;
16321 bool EvalResult =
false;
16322 bool EvalOK = Eval.evaluate(CO->
getCond(), EvalResult);
16323 bool ShouldVisitTrueExpr = !EvalOK || (EvalOK && EvalResult);
16324 bool ShouldVisitFalseExpr = !EvalOK || (EvalOK && !EvalResult);
16325 if (ShouldVisitTrueExpr) {
16326 Region = TrueRegion;
16329 if (ShouldVisitFalseExpr) {
16330 Region = FalseRegion;
16334 Region = OldRegion;
16335 Tree.merge(ConditionRegion);
16336 Tree.merge(TrueRegion);
16337 Tree.merge(FalseRegion);
16340 void VisitCallExpr(
const CallExpr *CE) {
16352 SequencedSubexpression Sequenced(*
this);
16357 SequenceTree::Seq CalleeRegion;
16358 SequenceTree::Seq OtherRegion;
16359 if (SemaRef.getLangOpts().CPlusPlus17) {
16360 CalleeRegion = Tree.allocate(Region);
16361 OtherRegion = Tree.allocate(Region);
16363 CalleeRegion = Region;
16364 OtherRegion = Region;
16366 SequenceTree::Seq OldRegion = Region;
16369 Region = CalleeRegion;
16371 SequencedSubexpression Sequenced(*this);
16372 Visit(CE->getCallee());
16374 Visit(CE->getCallee());
16378 Region = OtherRegion;
16382 Region = OldRegion;
16384 Tree.merge(CalleeRegion);
16385 Tree.merge(OtherRegion);
16403 return VisitCallExpr(CXXOCE);
16414 case OO_MinusEqual:
16416 case OO_SlashEqual:
16417 case OO_PercentEqual:
16418 case OO_CaretEqual:
16421 case OO_LessLessEqual:
16422 case OO_GreaterGreaterEqual:
16423 SequencingKind = RHSBeforeLHS;
16427 case OO_GreaterGreater:
16433 SequencingKind = LHSBeforeRHS;
16437 SequencingKind = LHSBeforeRest;
16441 SequencingKind = NoSequencing;
16445 if (SequencingKind == NoSequencing)
16446 return VisitCallExpr(CXXOCE);
16449 SequencedSubexpression Sequenced(*
this);
16452 assert(SemaRef.getLangOpts().CPlusPlus17 &&
16453 "Should only get there with C++17 and above!");
16454 assert((CXXOCE->getNumArgs() == 2 || CXXOCE->getOperator() == OO_Call) &&
16455 "Should only get there with an overloaded binary operator"
16456 " or an overloaded call operator!");
16458 if (SequencingKind == LHSBeforeRest) {
16459 assert(CXXOCE->getOperator() == OO_Call &&
16460 "We should only have an overloaded call operator here!");
16469 SequenceTree::Seq PostfixExprRegion = Tree.allocate(Region);
16470 SequenceTree::Seq ArgsRegion = Tree.allocate(Region);
16471 SequenceTree::Seq OldRegion = Region;
16473 assert(CXXOCE->getNumArgs() >= 1 &&
16474 "An overloaded call operator must have at least one argument"
16475 " for the postfix-expression!");
16476 const Expr *PostfixExpr = CXXOCE->getArgs()[0];
16477 llvm::ArrayRef<const Expr *> Args(CXXOCE->getArgs() + 1,
16478 CXXOCE->getNumArgs() - 1);
16482 Region = PostfixExprRegion;
16483 SequencedSubexpression Sequenced(*this);
16484 Visit(PostfixExpr);
16488 Region = ArgsRegion;
16489 for (const Expr *Arg : Args)
16492 Region = OldRegion;
16493 Tree.merge(PostfixExprRegion);
16494 Tree.merge(ArgsRegion);
16496 assert(CXXOCE->getNumArgs() == 2 &&
16497 "Should only have two arguments here!");
16498 assert((SequencingKind == LHSBeforeRHS ||
16499 SequencingKind == RHSBeforeLHS) &&
16500 "Unexpected sequencing kind!");
16504 const Expr *E1 = CXXOCE->getArg(0);
16505 const Expr *E2 = CXXOCE->getArg(1);
16506 if (SequencingKind == RHSBeforeLHS)
16509 return VisitSequencedExpressions(E1, E2);
16516 SequencedSubexpression Sequenced(*
this);
16519 return VisitExpr(CCE);
16523 SequenceTree::Seq
Parent = Region;
16528 Elts.push_back(Region);
16534 for (
unsigned I = 0; I < Elts.size(); ++I)
16535 Tree.merge(Elts[I]);
16540 return VisitExpr(ILE);
16544 SequenceTree::Seq
Parent = Region;
16545 for (
unsigned I = 0; I < ILE->
getNumInits(); ++I) {
16550 Elts.push_back(Region);
16556 for (
unsigned I = 0; I < Elts.size(); ++I)
16557 Tree.merge(Elts[I]);
16563void Sema::CheckUnsequencedOperations(
const Expr *E) {
16565 WorkList.push_back(E);
16566 while (!WorkList.empty()) {
16567 const Expr *Item = WorkList.pop_back_val();
16568 SequenceChecker(*
this, Item, WorkList);
16573 bool IsConstexpr) {
16575 IsConstexpr || isa<ConstantExpr>(E));
16576 CheckImplicitConversions(E, CheckLoc);
16578 CheckUnsequencedOperations(E);
16580 CheckForIntOverflow(E);
16594 if (
const auto *PointerTy = dyn_cast<PointerType>(PType)) {
16598 if (
const auto *ReferenceTy = dyn_cast<ReferenceType>(PType)) {
16602 if (
const auto *ParenTy = dyn_cast<ParenType>(PType)) {
16616 S.
Diag(Loc, diag::err_array_star_in_function_definition);
16625 bool CheckParameterNames) {
16626 bool HasInvalidParm =
false;
16628 assert(Param &&
"null in a parameter list");
16637 if (!Param->isInvalidDecl() &&
16639 diag::err_typecheck_decl_incomplete_type) ||
16641 diag::err_abstract_type_in_decl,
16643 Param->setInvalidDecl();
16644 HasInvalidParm =
true;
16649 if (CheckParameterNames && Param->getIdentifier() ==
nullptr &&
16653 Diag(Param->getLocation(), diag::ext_parameter_name_omitted_c2x);
16661 QualType PType = Param->getOriginalType();
16669 if (!Param->isInvalidDecl()) {
16670 if (
CXXRecordDecl *ClassDecl = Param->getType()->getAsCXXRecordDecl()) {
16671 if (!ClassDecl->isInvalidDecl() &&
16672 !ClassDecl->hasIrrelevantDestructor() &&
16673 !ClassDecl->isDependentContext() &&
16674 ClassDecl->isParamDestroyedInCallee()) {
16686 if (
const auto *
Attr = Param->getAttr<PassObjectSizeAttr>())
16687 if (!Param->getType().isConstQualified())
16688 Diag(Param->getLocation(), diag::err_attribute_pointers_only)
16692 if (
LangOpts.CPlusPlus && !Param->isInvalidDecl()) {
16697 if (
auto *RD = dyn_cast<CXXRecordDecl>(DC->
getParent()))
16698 CheckShadowInheritedFields(Param->getLocation(), Param->getDeclName(),
16703 if (!Param->isInvalidDecl() &&
16704 Param->getOriginalType()->isWebAssemblyTableType()) {
16705 Param->setInvalidDecl();
16706 HasInvalidParm =
true;
16707 Diag(Param->getLocation(), diag::err_wasm_table_as_function_parameter);
16711 return HasInvalidParm;
16714std::optional<std::pair<
16723static std::pair<CharUnits, CharUnits>
16731 if (
Base->isVirtual()) {
16738 BaseAlignment = std::min(BaseAlignment, NonVirtualAlignment);
16745 DerivedType =
Base->getType();
16748 return std::make_pair(BaseAlignment,
Offset);
16752static std::optional<std::pair<CharUnits, CharUnits>>
16758 return std::nullopt;
16763 return std::nullopt;
16770 return std::make_pair(
P->first,
P->second +
Offset);
16776 return std::make_pair(
16777 P->first.alignmentAtOffset(
P->second).alignmentAtOffset(EltSize),
16783std::optional<std::pair<
16791 case Stmt::CStyleCastExprClass:
16792 case Stmt::CXXStaticCastExprClass:
16793 case Stmt::ImplicitCastExprClass: {
16795 const Expr *From = CE->getSubExpr();
16796 switch (CE->getCastKind()) {
16801 case CK_UncheckedDerivedToBase:
16802 case CK_DerivedToBase: {
16812 case Stmt::ArraySubscriptExprClass: {
16817 case Stmt::DeclRefExprClass: {
16818 if (
auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
16821 if (!VD->getType()->isReferenceType()) {
16823 if (VD->hasDependentAlignment())
16832 case Stmt::MemberExprClass: {
16834 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
16838 std::optional<std::pair<CharUnits, CharUnits>>
P;
16847 return std::make_pair(
P->first,
16850 case Stmt::UnaryOperatorClass: {
16860 case Stmt::BinaryOperatorClass: {
16872 return std::nullopt;
16877std::optional<std::pair<
16886 case Stmt::CStyleCastExprClass:
16887 case Stmt::CXXStaticCastExprClass:
16888 case Stmt::ImplicitCastExprClass: {
16890 const Expr *From = CE->getSubExpr();
16891 switch (CE->getCastKind()) {
16896 case CK_ArrayToPointerDecay:
16898 case CK_UncheckedDerivedToBase:
16899 case CK_DerivedToBase: {
16909 case Stmt::CXXThisExprClass: {
16914 case Stmt::UnaryOperatorClass: {
16920 case Stmt::BinaryOperatorClass: {
16929 if (Opcode == BO_Add && !RHS->getType()->isIntegralOrEnumerationType())
16930 std::swap(LHS, RHS);
16940 return std::nullopt;
16945 std::optional<std::pair<CharUnits, CharUnits>>
P =
16949 return P->first.alignmentAtOffset(
P->second);
16969 if (!DestPtr)
return;
16975 if (DestAlign.
isOne())
return;
16979 if (!SrcPtr)
return;
16990 if (SrcAlign >= DestAlign)
return;
16995 <<
static_cast<unsigned>(DestAlign.
getQuantity())
16999void Sema::CheckArrayAccess(
const Expr *BaseExpr,
const Expr *IndexExpr,
17001 bool AllowOnePastEnd,
bool IndexNegated) {
17010 const Type *EffectiveType =
17017 StrictFlexArraysLevel =
getLangOpts().getStrictFlexArraysLevel();
17019 const Type *BaseType =
17021 bool IsUnboundedArray =
17023 Context, StrictFlexArraysLevel,
17026 (!IsUnboundedArray && BaseType->isDependentType()))
17034 if (IndexNegated) {
17035 index.setIsUnsigned(
false);
17039 if (IsUnboundedArray) {
17042 if (index.isUnsigned() || !index.isNegative()) {
17044 unsigned AddrBits = ASTC.getTargetInfo().getPointerWidth(
17046 if (index.getBitWidth() < AddrBits)
17047 index = index.zext(AddrBits);
17048 std::optional<CharUnits> ElemCharUnits =
17049 ASTC.getTypeSizeInCharsIfKnown(EffectiveType);
17052 if (!ElemCharUnits)
17054 llvm::APInt ElemBytes(index.getBitWidth(), ElemCharUnits->getQuantity());
17059 if (index.getActiveBits() <= AddrBits) {
17061 llvm::APInt Product(index);
17063 Product = Product.umul_ov(ElemBytes, Overflow);
17064 if (!Overflow && Product.getActiveBits() <= AddrBits)
17070 llvm::APInt MaxElems = llvm::APInt::getMaxValue(AddrBits);
17071 MaxElems = MaxElems.zext(std::max(AddrBits + 1, ElemBytes.getBitWidth()));
17073 ElemBytes = ElemBytes.zextOrTrunc(MaxElems.getBitWidth());
17074 MaxElems = MaxElems.udiv(ElemBytes);
17077 ASE ? diag::warn_array_index_exceeds_max_addressable_bounds
17078 : diag::warn_ptr_arith_exceeds_max_addressable_bounds;
17084 <<
toString(index, 10,
true) << AddrBits
17085 << (
unsigned)ASTC.toBits(*ElemCharUnits)
17088 << (
unsigned)MaxElems.getLimitedValue(~0
U)
17093 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
17095 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
17097 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
17098 ND = ME->getMemberDecl();
17102 PDiag(diag::note_array_declared_here) << ND);
17107 if (index.isUnsigned() || !index.isNegative()) {
17114 if (BaseType->isIncompleteType())
17117 llvm::APInt size = ArrayTy->
getSize();
17119 if (BaseType != EffectiveType) {
17127 if (!ptrarith_typesize)
17130 if (ptrarith_typesize != array_typesize) {
17132 uint64_t ratio = array_typesize / ptrarith_typesize;
17136 if (ptrarith_typesize * ratio == array_typesize)
17137 size *= llvm::APInt(size.getBitWidth(), ratio);
17141 if (size.getBitWidth() > index.getBitWidth())
17142 index = index.zext(size.getBitWidth());
17143 else if (size.getBitWidth() < index.getBitWidth())
17144 size = size.zext(index.getBitWidth());
17150 if (AllowOnePastEnd ? index.ule(size) : index.ult(size))
17159 if (SourceMgr.isInSystemHeader(RBracketLoc)) {
17161 SourceMgr.getSpellingLoc(IndexExpr->
getBeginLoc());
17162 if (SourceMgr.isWrittenInSameFile(RBracketLoc, IndexLoc))
17167 unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds
17168 : diag::warn_ptr_arith_exceeds_bounds;
17169 unsigned CastMsg = (!ASE || BaseType == EffectiveType) ? 0 : 1;
17177 unsigned DiagID = diag::warn_array_index_precedes_bounds;
17179 DiagID = diag::warn_ptr_arith_precedes_bounds;
17180 if (index.isNegative()) index = -index;
17190 while (
const auto *ASE = dyn_cast<ArraySubscriptExpr>(BaseExpr))
17192 if (
const auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
17194 if (
const auto *ME = dyn_cast<MemberExpr>(BaseExpr))
17195 ND = ME->getMemberDecl();
17199 PDiag(diag::note_array_declared_here) << ND);
17202void Sema::CheckArrayAccess(
const Expr *
expr) {
17203 int AllowOnePastEnd = 0;
17205 expr =
expr->IgnoreParenImpCasts();
17206 switch (
expr->getStmtClass()) {
17207 case Stmt::ArraySubscriptExprClass: {
17210 AllowOnePastEnd > 0);
17214 case Stmt::MemberExprClass: {
17218 case Stmt::OMPArraySectionExprClass: {
17222 nullptr, AllowOnePastEnd > 0);
17225 case Stmt::UnaryOperatorClass: {
17241 case Stmt::ConditionalOperatorClass: {
17244 CheckArrayAccess(lhs);
17246 CheckArrayAccess(rhs);
17249 case Stmt::CXXOperatorCallExprClass: {
17251 for (
const auto *Arg : OCE->arguments())
17252 CheckArrayAccess(Arg);
17265struct RetainCycleOwner {
17269 bool Indirect =
false;
17271 RetainCycleOwner() =
default;
17273 void setLocsFrom(
Expr *e) {
17290 owner.Variable = var;
17292 owner.setLocsFrom(ref);
17299 if (
CastExpr *cast = dyn_cast<CastExpr>(e)) {
17300 switch (cast->getCastKind()) {
17302 case CK_LValueBitCast:
17303 case CK_LValueToRValue:
17304 case CK_ARCReclaimReturnedObject:
17305 e = cast->getSubExpr();
17322 if (ref->isFreeIvar()) owner.setLocsFrom(ref);
17323 owner.Indirect =
true;
17327 if (
DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) {
17328 VarDecl *var = dyn_cast<VarDecl>(ref->getDecl());
17329 if (!var)
return false;
17333 if (
MemberExpr *member = dyn_cast<MemberExpr>(e)) {
17334 if (member->isArrow())
return false;
17337 e = member->getBase();
17344 = dyn_cast<ObjCPropertyRefExpr>(pseudo->getSyntacticForm()
17346 if (!pre)
return false;
17349 if (!property->isRetaining() &&
17350 !(property->getPropertyIvarDecl() &&
17351 property->getPropertyIvarDecl()->getType()
17355 owner.Indirect =
true;
17358 if (!owner.Variable)
17365 ->getSourceExpr());
17379 Expr *Capturer =
nullptr;
17380 bool VarWillBeReased =
false;
17387 if (ref->
getDecl() == Variable && !Capturer)
17392 if (Capturer)
return;
17398 void VisitBlockExpr(
BlockExpr *block) {
17405 if (Capturer)
return;
17411 if (!Variable || VarWillBeReased || BinOp->
getOpcode() != BO_Assign)
17414 if (
const DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(LHS)) {
17415 if (DRE->
getDecl() != Variable)
17418 RHS = RHS->IgnoreParenCasts();
17419 std::optional<llvm::APSInt>
Value;
17421 (RHS && (
Value = RHS->getIntegerConstantExpr(Context)) &&
17433 assert(owner.Variable && owner.Loc.
isValid());
17440 if (
Cmd.isUnarySelector() &&
Cmd.getNameForSlot(0) ==
"copy") {
17441 e = ME->getInstanceReceiver();
17446 }
else if (
CallExpr *CE = dyn_cast<CallExpr>(e)) {
17451 if (FnI && FnI->
isStr(
"_Block_copy")) {
17458 BlockExpr *block = dyn_cast<BlockExpr>(e);
17462 FindCaptureVisitor visitor(S.
Context, owner.Variable);
17464 return visitor.VarWillBeReased ? nullptr : visitor.Capturer;
17468 RetainCycleOwner &owner) {
17470 assert(owner.Variable && owner.Loc.
isValid());
17474 S.
Diag(owner.Loc, diag::note_arc_retain_cycle_owner)
17475 << owner.Indirect << owner.Range;
17484 while (!str.empty() && str.front() ==
'_') str = str.substr(1);
17485 if (str.startswith(
"set"))
17486 str = str.substr(3);
17487 else if (str.startswith(
"add")) {
17489 if (sel.
getNumArgs() == 1 && str.startswith(
"addOperationWithBlock"))
17491 str = str.substr(3);
17496 if (str.empty())
return true;
17500static std::optional<int>
17502 bool IsMutableArray = S.
NSAPIObj->isSubclassOfNSClass(
17503 Message->getReceiverInterface(),
17505 if (!IsMutableArray) {
17506 return std::nullopt;
17509 Selector Sel = Message->getSelector();
17511 std::optional<NSAPI::NSArrayMethodKind> MKOpt =
17512 S.
NSAPIObj->getNSArrayMethodKind(Sel);
17514 return std::nullopt;
17528 return std::nullopt;
17531 return std::nullopt;
17534static std::optional<int>
17536 bool IsMutableDictionary = S.
NSAPIObj->isSubclassOfNSClass(
17537 Message->getReceiverInterface(),
17539 if (!IsMutableDictionary) {
17540 return std::nullopt;
17543 Selector Sel = Message->getSelector();
17545 std::optional<NSAPI::NSDictionaryMethodKind> MKOpt =
17546 S.
NSAPIObj->getNSDictionaryMethodKind(Sel);
17548 return std::nullopt;
17560 return std::nullopt;
17563 return std::nullopt;
17568 bool IsMutableSet = S.
NSAPIObj->isSubclassOfNSClass(
17569 Message->getReceiverInterface(),
17572 bool IsMutableOrderedSet = S.
NSAPIObj->isSubclassOfNSClass(
17573 Message->getReceiverInterface(),
17575 if (!IsMutableSet && !IsMutableOrderedSet) {
17576 return std::nullopt;
17579 Selector Sel = Message->getSelector();
17581 std::optional<NSAPI::NSSetMethodKind> MKOpt =
17582 S.
NSAPIObj->getNSSetMethodKind(Sel);
17584 return std::nullopt;
17599 return std::nullopt;
17603 if (!Message->isInstanceMessage()) {
17607 std::optional<int> ArgOpt;
17615 int ArgIndex = *ArgOpt;
17617 Expr *Arg = Message->getArg(ArgIndex)->IgnoreImpCasts();
17623 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
17624 if (ArgRE->isObjCSelfExpr()) {
17625 Diag(Message->getSourceRange().getBegin(),
17626 diag::warn_objc_circular_container)
17627 << ArgRE->getDecl() << StringRef(
"'super'");
17631 Expr *Receiver = Message->getInstanceReceiver()->IgnoreImpCasts();
17637 if (
DeclRefExpr *ReceiverRE = dyn_cast<DeclRefExpr>(Receiver)) {
17638 if (
DeclRefExpr *ArgRE = dyn_cast<DeclRefExpr>(Arg)) {
17639 if (ReceiverRE->getDecl() == ArgRE->getDecl()) {
17641 Diag(Message->getSourceRange().getBegin(),
17642 diag::warn_objc_circular_container)
17644 if (!ArgRE->isObjCSelfExpr()) {
17646 diag::note_objc_circular_container_declared_here)
17651 }
else if (
ObjCIvarRefExpr *IvarRE = dyn_cast<ObjCIvarRefExpr>(Receiver)) {
17653 if (IvarRE->getDecl() == IvarArgRE->getDecl()) {
17655 Diag(Message->getSourceRange().getBegin(),
17656 diag::warn_objc_circular_container)
17659 diag::note_objc_circular_container_declared_here)
17674 RetainCycleOwner owner;
17687 for (
unsigned i = 0, e = msg->
getNumArgs(); i != e; ++i) {
17690 if (MD && MD->
parameters()[i]->hasAttr<NoEscapeAttr>())
17699 RetainCycleOwner owner;
17708 RetainCycleOwner Owner;
17722 Expr *RHS,
bool isProperty) {
17734 S.
Diag(Loc, diag::warn_arc_literal_assign)
17736 << (isProperty ? 0 : 1)
17744 Expr *RHS,
bool isProperty) {
17747 if (cast->getCastKind() == CK_ARCConsumeObject) {
17748 S.
Diag(Loc, diag::warn_arc_retained_assign)
17750 << (isProperty ? 0 : 1)
17754 RHS = cast->getSubExpr();
17825 if (cast->getCastKind() == CK_ARCConsumeObject) {
17826 Diag(Loc, diag::warn_arc_retained_property_assign)
17830 RHS = cast->getSubExpr();
17853 bool StmtLineInvalid;
17854 unsigned StmtLine = SourceMgr.getPresumedLineNumber(StmtLoc,
17856 if (StmtLineInvalid)
17859 bool BodyLineInvalid;
17860 unsigned BodyLine = SourceMgr.getSpellingLineNumber(Body->
getSemiLoc(),
17862 if (BodyLineInvalid)
17866 if (StmtLine != BodyLine)
17881 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
17890 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
17894 const Stmt *PossibleBody) {
17900 if (
const ForStmt *FS = dyn_cast<ForStmt>(S)) {
17901 StmtLoc = FS->getRParenLoc();
17902 Body = FS->getBody();
17903 DiagID = diag::warn_empty_for_body;
17904 }
else if (
const WhileStmt *WS = dyn_cast<WhileStmt>(S)) {
17905 StmtLoc = WS->getRParenLoc();
17906 Body = WS->getBody();
17907 DiagID = diag::warn_empty_while_body;
17912 const NullStmt *NBody = dyn_cast<NullStmt>(Body);
17936 if (!ProbableTypo) {
17937 bool BodyColInvalid;
17938 unsigned BodyCol = SourceMgr.getPresumedColumnNumber(
17940 if (BodyColInvalid)
17943 bool StmtColInvalid;
17945 SourceMgr.getPresumedColumnNumber(S->getBeginLoc(), &StmtColInvalid);
17946 if (StmtColInvalid)
17949 if (BodyCol > StmtCol)
17950 ProbableTypo =
true;
17953 if (ProbableTypo) {
17955 Diag(NBody->
getSemiLoc(), diag::note_empty_body_on_separate_line);
17964 if (
Diags.
isIgnored(diag::warn_sizeof_pointer_expr_memaccess, OpLoc))
17975 const CallExpr *CE = dyn_cast<CallExpr>(RHSExpr);
17984 RHSExpr = CE->
getArg(0);
17986 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
17987 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
17990 if (LHSDeclRef && RHSDeclRef) {
17997 auto D =
Diag(OpLoc, diag::warn_self_move)
18013 const Expr *LHSBase = LHSExpr;
18014 const Expr *RHSBase = RHSExpr;
18015 const MemberExpr *LHSME = dyn_cast<MemberExpr>(LHSExpr);
18016 const MemberExpr *RHSME = dyn_cast<MemberExpr>(RHSExpr);
18017 if (!LHSME || !RHSME)
18020 while (LHSME && RHSME) {
18027 LHSME = dyn_cast<MemberExpr>(LHSBase);
18028 RHSME = dyn_cast<MemberExpr>(RHSBase);
18031 LHSDeclRef = dyn_cast<DeclRefExpr>(LHSBase);
18032 RHSDeclRef = dyn_cast<DeclRefExpr>(RHSBase);
18033 if (LHSDeclRef && RHSDeclRef) {
18040 Diag(OpLoc, diag::warn_self_move)
18046 if (isa<CXXThisExpr>(LHSBase) && isa<CXXThisExpr>(RHSBase))
18047 Diag(OpLoc, diag::warn_self_move)
18079 if (Bits1 != Bits2)
18091 if (
const CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(RD1)) {
18096 if (D1CXX->getNumBases() != D2CXX->
getNumBases())
18101 Base1 = D1CXX->bases_begin(),
18102 BaseEnd1 = D1CXX->bases_end(),
18105 ++Base1, ++Base2) {
18109 }
else if (
const CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(RD2)) {
18111 if (D2CXX->getNumBases() > 0)
18120 for ( ; Field1 != Field1End && Field2 != Field2End; ++Field1, ++Field2) {
18124 if (Field1 != Field1End || Field2 != Field2End)
18135 for (
auto *Field2 : RD2->
fields())
18136 UnmatchedFields.insert(Field2);
18138 for (
auto *Field1 : RD1->
fields()) {
18140 I = UnmatchedFields.begin(),
18141 E = UnmatchedFields.end();
18143 for ( ; I != E; ++I) {
18145 bool Result = UnmatchedFields.erase(*I);
18155 return UnmatchedFields.empty();
18177 if (
C.hasSameType(T1, T2))
18189 if (TC1 == Type::Enum) {
18191 cast<EnumType>(T1)->getDecl(),
18192 cast<EnumType>(T2)->getDecl());
18193 }
else if (TC1 == Type::Record) {
18198 cast<RecordType>(T1)->getDecl(),
18199 cast<RecordType>(T2)->getDecl());
18219 const ValueDecl **VD, uint64_t *MagicValue,
18220 bool isConstantEvaluated) {
18228 case Stmt::UnaryOperatorClass: {
18237 case Stmt::DeclRefExprClass: {
18243 case Stmt::IntegerLiteralClass: {
18245 llvm::APInt MagicValueAPInt = IL->
getValue();
18246 if (MagicValueAPInt.getActiveBits() <= 64) {
18247 *MagicValue = MagicValueAPInt.getZExtValue();
18253 case Stmt::BinaryConditionalOperatorClass:
18254 case Stmt::ConditionalOperatorClass: {
18259 isConstantEvaluated)) {
18269 case Stmt::BinaryOperatorClass: {
18272 TypeExpr = BO->
getRHS();
18302 const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
18305 bool isConstantEvaluated) {
18306 FoundWrongKind =
false;
18311 uint64_t MagicValue;
18313 if (!
FindTypeTagExpr(TypeExpr, Ctx, &VD, &MagicValue, isConstantEvaluated))
18317 if (TypeTagForDatatypeAttr *I = VD->
getAttr<TypeTagForDatatypeAttr>()) {
18318 if (I->getArgumentKind() != ArgumentKind) {
18319 FoundWrongKind =
true;
18322 TypeInfo.Type = I->getMatchingCType();
18323 TypeInfo.LayoutCompatible = I->getLayoutCompatible();
18324 TypeInfo.MustBeNull = I->getMustBeNull();
18335 MagicValues->find(std::make_pair(ArgumentKind, MagicValue));
18336 if (I == MagicValues->end())
18345 bool LayoutCompatible,
18347 if (!TypeTagForDatatypeMagicValues)
18348 TypeTagForDatatypeMagicValues.reset(
18349 new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);
18352 (*TypeTagForDatatypeMagicValues)[Magic] =
18368 return (T1Kind == BuiltinType::SChar && T2Kind == BuiltinType::Char_S) ||
18369 (T1Kind == BuiltinType::UChar && T2Kind == BuiltinType::Char_U) ||
18370 (T1Kind == BuiltinType::Char_U && T2Kind == BuiltinType::UChar) ||
18371 (T1Kind == BuiltinType::Char_S && T2Kind == BuiltinType::SChar);
18374void Sema::CheckArgumentWithTypeTag(
const ArgumentWithTypeTagAttr *
Attr,
18378 bool IsPointerAttr =
Attr->getIsPointer();
18381 unsigned TypeTagIdxAST =
Attr->getTypeTagIdx().getASTIndex();
18382 if (TypeTagIdxAST >= ExprArgs.size()) {
18383 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
18384 << 0 <<
Attr->getTypeTagIdx().getSourceIndex();
18387 const Expr *TypeTagExpr = ExprArgs[TypeTagIdxAST];
18388 bool FoundWrongKind;
18391 TypeTagForDatatypeMagicValues.get(), FoundWrongKind,
18393 if (FoundWrongKind)
18395 diag::warn_type_tag_for_datatype_wrong_kind)
18401 unsigned ArgumentIdxAST =
Attr->getArgumentIdx().getASTIndex();
18402 if (ArgumentIdxAST >= ExprArgs.size()) {
18403 Diag(CallSiteLoc, diag::err_tag_index_out_of_range)
18404 << 1 <<
Attr->getArgumentIdx().getSourceIndex();
18407 const Expr *ArgumentExpr = ExprArgs[ArgumentIdxAST];
18408 if (IsPointerAttr) {
18410 if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgumentExpr))
18411 if (ICE->getType()->isVoidPointerType() &&
18412 ICE->getCastKind() == CK_BitCast)
18413 ArgumentExpr = ICE->getSubExpr();
18426 diag::warn_type_safety_null_pointer_required)
18438 bool mismatch =
false;
18461 Diag(ArgumentExpr->
getExprLoc(), diag::warn_type_safety_type_mismatch)
18462 << ArgumentType << ArgumentKind
18463 <<
TypeInfo.LayoutCompatible << RequiredType
18470 MisalignedMembers.emplace_back(E, RD, MD, Alignment);
18474 for (MisalignedMember &m : MisalignedMembers) {
18480 Diag(m.E->getBeginLoc(), diag::warn_taking_address_of_packed_member)
18483 MisalignedMembers.clear();
18488 if (!T->isPointerType() && !T->isIntegerType() && !T->isDependentType())
18490 if (isa<UnaryOperator>(E) &&
18491 cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf) {
18493 if (isa<MemberExpr>(Op)) {
18494 auto *MA = llvm::find(MisalignedMembers, MisalignedMember(Op));
18495 if (MA != MisalignedMembers.end() &&
18496 (T->isDependentType() || T->isIntegerType() ||
18497 (T->isPointerType() && (T->getPointeeType()->isIncompleteType() ||
18499 T->getPointeeType()) <= MA->Alignment))))
18500 MisalignedMembers.erase(MA);
18509 const auto *ME = dyn_cast<MemberExpr>(E);
18521 bool AnyIsPacked =
false;
18523 QualType BaseType = ME->getBase()->getType();
18524 if (BaseType->isDependentType())
18528 RecordDecl *RD = BaseType->castAs<RecordType>()->getDecl();
18533 auto *FD = dyn_cast<FieldDecl>(MD);
18539 AnyIsPacked || (RD->
hasAttr<PackedAttr>() || MD->
hasAttr<PackedAttr>());
18540 ReverseMemberChain.push_back(FD);
18543 ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParens());
18545 assert(TopME &&
"We did not compute a topmost MemberExpr!");
18552 const auto *DRE = dyn_cast<DeclRefExpr>(TopBase);
18556 if (!DRE && !isa<CXXThisExpr>(TopBase))
18563 if (ExpectedAlignment.
isOne())
18568 for (
const FieldDecl *FD : llvm::reverse(ReverseMemberChain))
18573 ReverseMemberChain.back()->getParent()->getTypeForDecl());
18577 if (DRE && !TopME->
isArrow()) {
18580 CompleteObjectAlignment =
18585 if (
Offset % ExpectedAlignment != 0 ||
18588 CompleteObjectAlignment < ExpectedAlignment) {
18599 for (
FieldDecl *FDI : ReverseMemberChain) {
18600 if (FDI->hasAttr<PackedAttr>() ||
18601 FDI->getParent()->hasAttr<PackedAttr>()) {
18603 Alignment = std::min(
18609 assert(FD &&
"We did not find a packed FieldDecl!");
18610 Action(E, FD->
getParent(), FD, Alignment);
18614void Sema::CheckAddressOfPackedMember(
Expr *rhs) {
18615 using namespace std::placeholders;
18618 rhs, std::bind(&Sema::AddPotentialMisalignedMembers, std::ref(*
this), _1,
18622bool Sema::PrepareBuiltinElementwiseMathOneArgCall(
CallExpr *TheCall) {
18640bool Sema::SemaBuiltinElementwiseMath(
CallExpr *TheCall) {
18658 diag::err_typecheck_call_different_arg_types)
18670bool Sema::SemaBuiltinElementwiseTernaryMath(
CallExpr *TheCall) {
18675 for (
int I = 0; I < 3; ++I) {
18679 Args[I] = Converted.
get();
18682 int ArgOrdinal = 1;
18683 for (
Expr *Arg : Args) {
18689 for (
int I = 1; I < 3; ++I) {
18690 if (Args[0]->
getType().getCanonicalType() !=
18691 Args[I]->
getType().getCanonicalType()) {
18692 return Diag(Args[0]->getBeginLoc(),
18693 diag::err_typecheck_call_different_arg_types)
18694 << Args[0]->getType() << Args[I]->getType();
18697 TheCall->
setArg(I, Args[I]);
18704bool Sema::PrepareBuiltinReduceMathOneArgCall(
CallExpr *TheCall) {
18716bool Sema::SemaBuiltinNonDeterministicValue(
CallExpr *TheCall) {
18725 << 1 << 0 << TyArg;
18739 Expr *Matrix = MatrixArg.
get();
18744 << 1 << 1 << Matrix->
getType();
18751 MType->getElementType(), MType->getNumColumns(), MType->getNumRows());
18754 TheCall->
setType(ResultType);
18757 TheCall->
setArg(0, Matrix);
18762static std::optional<unsigned>
18765 std::optional<llvm::APSInt>
Value =
18772 uint64_t Dim =
Value->getZExtValue();
18791 unsigned PtrArgIdx = 0;
18797 bool ArgError =
false;
18804 PtrExpr = PtrConv.
get();
18805 TheCall->
setArg(0, PtrExpr);
18816 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
18819 ElementTy = PtrTy->getPointeeType().getUnqualifiedType();
18823 << PtrArgIdx + 1 << 2
18830 auto ApplyArgumentConversions = [
this](
Expr *E) {
18839 ExprResult RowsConv = ApplyArgumentConversions(RowsExpr);
18841 RowsExpr = RowsConv.
get();
18842 TheCall->
setArg(1, RowsExpr);
18844 RowsExpr =
nullptr;
18846 ExprResult ColumnsConv = ApplyArgumentConversions(ColumnsExpr);
18848 ColumnsExpr = ColumnsConv.
get();
18849 TheCall->
setArg(2, ColumnsExpr);
18851 ColumnsExpr =
nullptr;
18862 std::optional<unsigned> MaybeRows;
18866 std::optional<unsigned> MaybeColumns;
18871 ExprResult StrideConv = ApplyArgumentConversions(StrideExpr);
18874 StrideExpr = StrideConv.
get();
18875 TheCall->
setArg(3, StrideExpr);
18878 if (std::optional<llvm::APSInt>
Value =
18880 uint64_t Stride =
Value->getZExtValue();
18881 if (Stride < *MaybeRows) {
18883 diag::err_builtin_matrix_stride_too_small);
18889 if (ArgError || !MaybeRows || !MaybeColumns)
18902 unsigned PtrArgIdx = 1;
18907 bool ArgError =
false;
18913 MatrixExpr = MatrixConv.
get();
18914 TheCall->
setArg(0, MatrixExpr);
18924 << 1 << 1 << MatrixExpr->
getType();
18932 PtrExpr = PtrConv.
get();
18933 TheCall->
setArg(1, PtrExpr);
18944 << PtrArgIdx + 1 << 2 << PtrExpr->
getType();
18949 Diag(PtrExpr->
getBeginLoc(), diag::err_builtin_matrix_store_to_const);
18956 diag::err_builtin_matrix_pointer_arg_mismatch)
18957 << ElementTy << MatrixTy->getElementType();
18972 StrideExpr = StrideConv.
get();
18973 TheCall->
setArg(2, StrideExpr);
18978 if (std::optional<llvm::APSInt>
Value =
18980 uint64_t Stride =
Value->getZExtValue();
18981 if (Stride < MatrixTy->getNumRows()) {
18983 diag::err_builtin_matrix_stride_too_small);
19000 const auto *ATy = dyn_cast<ArrayType>(ArgExpr->
getType());
19001 if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
19003 diag::err_wasm_builtin_arg_must_be_table_type)
19006 ElTy = ATy->getElementType();
19012 unsigned ArgIndex) {
19016 diag::err_wasm_builtin_arg_must_be_integer_type)
19024bool Sema::BuiltinWasmTableGet(
CallExpr *TheCall) {
19047bool Sema::BuiltinWasmTableSet(
CallExpr *TheCall) {
19065bool Sema::BuiltinWasmTableSize(
CallExpr *TheCall) {
19079bool Sema::BuiltinWasmTableGrow(
CallExpr *TheCall) {
19090 diag::err_wasm_builtin_arg_must_match_table_element_type)
19103bool Sema::BuiltinWasmTableFill(
CallExpr *TheCall) {
19117 diag::err_wasm_builtin_arg_must_match_table_element_type)
19130bool Sema::BuiltinWasmTableCopy(
CallExpr *TheCall) {
19145 diag::err_wasm_builtin_arg_must_match_table_element_type)
19149 for (
int I = 2; I <= 4; I++) {
19169 if (!Caller || !Caller->
hasAttr<EnforceTCBAttr>())
19174 llvm::StringSet<> CalleeTCBs;
19175 for (
const auto *A :
Callee->specific_attrs<EnforceTCBAttr>())
19176 CalleeTCBs.insert(A->getTCBName());
19177 for (
const auto *A :
Callee->specific_attrs<EnforceTCBLeafAttr>())
19178 CalleeTCBs.insert(A->getTCBName());
19182 for (
const auto *A : Caller->
specific_attrs<EnforceTCBAttr>()) {
19183 StringRef CallerTCB = A->getTCBName();
19184 if (CalleeTCBs.count(CallerTCB) == 0) {
19185 this->
Diag(CallExprLoc, diag::warn_tcb_enforcement_violation)
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
Provides definitions for the various language-specific address spaces.
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
static bool getTypeString(SmallStringEnc &Enc, const Decl *D, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
The XCore ABI includes a type information section that communicates symbol type information to the li...
static Decl::Kind getKind(const Decl *D)
static QualType getThisObjectType(ASTContext &C, const FunctionProtoType *FPT, const CXXRecordDecl *Decl)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines the clang::OpenCLOptions class.
Defines an enumeration for C++ overloaded operators.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx, const ValueDecl **VD, uint64_t *MagicValue, bool isConstantEvaluated)
Given a type tag expression find the type tag itself.
static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth, bool InConstantContext, bool Approximate)
Pseudo-evaluate the given integer expression, estimating the range of values it might take.
static void CheckConditionalOperator(Sema &S, AbstractConditionalOperator *E, SourceLocation CC, QualType T)
static QualType getSizeOfArgType(const Expr *E)
If E is a sizeof expression, returns its argument type.
static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc)
static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, IdentifierInfo *FnName, SourceLocation FnLoc, SourceLocation RParenLoc)
Takes the expression passed to the size_t parameter of functions such as memcmp, strncat,...
static const CXXRecordDecl * getContainedDynamicClass(QualType T, bool &IsContained)
Determine whether the given type is or contains a dynamic class type (e.g., whether it has a vtable).
static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext)
Diagnose an implicit cast from a floating point value to an integer value.
static void CheckFormatString(Sema &S, const FormatStringLiteral *FExpr, const Expr *OrigFormatExpr, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, bool inFunctionCall, Sema::VariadicCallType CallType, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, bool IgnoreStringsWithoutSpecifiers)
static bool considerVariable(VarDecl *var, Expr *ref, RetainCycleOwner &owner)
Consider whether capturing the given variable can possibly lead to a retain cycle.
static void CheckImplicitConversion(Sema &S, Expr *E, QualType T, SourceLocation CC, bool *ICContext=nullptr, bool IsListInit=false)
static bool IsSameFloatAfterCast(const llvm::APFloat &value, const llvm::fltSemantics &Src, const llvm::fltSemantics &Tgt)
Checks whether the given value, which currently has the given source semantics, has the same value wh...
static StringLiteralCheckType checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef< const Expr * > Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, Sema::VariadicCallType CallType, bool InFunctionCall, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset, bool IgnoreStringsWithoutSpecifiers=false)
static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth)
static bool SemaBuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall)
static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool)
static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T, SourceLocation CContext, unsigned diag, bool pruneControlFlow=false)
Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg)
OpenCL C v2.0, s6.13.17.2 - Checks that the block parameters are all local void*, which is a requirem...
static bool isX86_32Builtin(unsigned BuiltinID)
static void AnalyzeComparison(Sema &S, BinaryOperator *E)
Implements -Wsign-compare.
static void sumOffsets(llvm::APSInt &Offset, llvm::APSInt Addend, BinaryOperatorKind BinOpKind, bool AddendIsRight)
static std::pair< QualType, StringRef > shouldNotPrintDirectly(const ASTContext &Context, QualType IntendedTy, const Expr *E)
static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_addressof is a glvalue, and set the result type to the correspon...
static ExprResult SemaBuiltinDumpStruct(Sema &S, CallExpr *TheCall)
static bool SemaBuiltinFunctionStart(Sema &S, CallExpr *TheCall)
Check that the argument to __builtin_function_start is a function.
static bool SemaBuiltinPreserveAI(Sema &S, CallExpr *TheCall)
Check the number of arguments and set the result type to the argument type.
static QualType GetExprType(const Expr *E)
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromLValue(const Expr *E, ASTContext &Ctx)
This helper function takes an lvalue expression and returns the alignment of a VarDecl and a constant...
static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall, SourceLocation CC)
static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant)
static AbsoluteValueKind getAbsoluteValueKind(QualType T)
static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID)
static bool SemaBuiltinCpuSupports(Sema &S, const TargetInfo &TI, CallExpr *TheCall)
SemaBuiltinCpuSupports - Handle __builtin_cpu_supports(char *).
static bool isKnownToHaveUnsignedValue(Expr *E)
static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout structs are layout-compatible.
static unsigned RFT(unsigned t, bool shift=false, bool ForceQuad=false)
static bool SemaBuiltinRWPipe(Sema &S, CallExpr *Call)
static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntType)
Diagnose integer type and any valid implicit conversion to it.
static bool isValidOrderingForOp(int64_t Ordering, AtomicExpr::AtomicOp Op)
static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E)
Analyze the given compound assignment for the possible losing of floating-point precision.
static bool doesExprLikelyComputeSize(const Expr *SizeofExpr)
Detect if SizeofExpr is likely to calculate the sizeof an object.
static bool isObjCSignedCharBool(Sema &S, QualType Ty)
static bool SemaBuiltinReserveRWPipe(Sema &S, CallExpr *Call)
static bool isValidBPFPreserveTypeInfoArg(Expr *Arg)
static bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID)
Check that the value argument for __builtin_is_aligned(value, alignment) and __builtin_aligned_{up,...
static bool CheckForReference(Sema &SemaRef, const Expr *E, const PartialDiagnostic &PD)
static const UnaryExprOrTypeTraitExpr * getAsSizeOfExpr(const Expr *E)
static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC)
Check conversion of given expression to boolean.
static bool SemaOpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different overload formats specified ...
static Expr * findCapturingExpr(Sema &S, Expr *e, RetainCycleOwner &owner)
Check whether the given argument is a block which captures a variable.
static bool checkArgCountAtLeast(Sema &S, CallExpr *Call, unsigned MinArgCount)
Checks that a call expression's argument count is at least the desired number.
static bool SemaBuiltinCpuIs(Sema &S, const TargetInfo &TI, CallExpr *TheCall)
SemaBuiltinCpuIs - Handle __builtin_cpu_is(char *).
static void CheckMemaccessSize(Sema &S, unsigned BId, const CallExpr *Call)
Diagnose cases like 'memset(buf, sizeof(buf), 0)', which should have the last two arguments transpose...
static std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range)
static const Expr * getStrlenExprArg(const Expr *E)
static void checkObjCDictionaryLiteral(Sema &S, QualType TargetType, ObjCDictionaryLiteral *DictionaryLiteral)
Check an Objective-C dictionary literal being converted to the given target type.
static bool isConstantSizeArrayWithMoreThanOneElement(QualType Ty, ASTContext &Context)
static bool isBlockPointer(Expr *Arg)
static bool isSetterLikeSelector(Selector sel)
Check for a keyword selector that starts with the word 'add' or 'set'.
static bool CheckWasmBuiltinArgIsTable(Sema &S, CallExpr *E, unsigned ArgIndex, QualType &ElTy)
Checks the argument at the given index is a WebAssembly table and if it is, sets ElTy to the element ...
static std::optional< int > GetNSMutableDictionaryArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static void adornObjCBoolConversionDiagWithTernaryFixit(Sema &S, Expr *SourceExpr, const Sema::SemaDiagnosticBuilder &Builder)
static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall, Expr *BlockArg, unsigned NumNonVarArgs)
OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all 'local void*' parameter of passed blo...
static bool IsSameCharType(QualType T1, QualType T2)
static OpenCLAccessAttr * getOpenCLArgAccess(const Decl *D)
Returns OpenCL access qual.
static bool CheckNonNullExpr(Sema &S, const Expr *Expr)
Checks if a the given expression evaluates to null.
static bool isArgumentExpandedFromMacro(SourceManager &SM, SourceLocation CallLoc, SourceLocation ArgLoc)
Check if the ArgLoc originated from a macro passed to the call at CallLoc.
static const IntegerLiteral * getIntegerLiteral(Expr *E)
static bool checkMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType Ty)
static const Expr * maybeConstEvalStringLiteral(ASTContext &Context, const Expr *E)
static bool IsStdFunction(const FunctionDecl *FDecl, const char(&Str)[StrLen])
static void AnalyzeAssignment(Sema &S, BinaryOperator *E)
Analyze the given simple or compound assignment for warning-worthy operations.
static bool ShouldDiagnoseEmptyStmtBody(const SourceManager &SourceMgr, SourceLocation StmtLoc, const NullStmt *Body)
static std::pair< CharUnits, CharUnits > getDerivedToBaseAlignmentAndOffset(const CastExpr *CE, QualType DerivedType, CharUnits BaseAlignment, CharUnits Offset, ASTContext &Ctx)
Compute the alignment and offset of the base class object given the derived-to-base cast expression a...
static void diagnoseArrayStarInParamType(Sema &S, QualType PType, SourceLocation Loc)
static unsigned changeAbsFunction(unsigned AbsKind, AbsoluteValueKind ValueKind)
static void CheckConditionalOperand(Sema &S, Expr *E, QualType T, SourceLocation CC, bool &ICContext)
static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2)
Check if two types are layout-compatible in C++11 sense.
static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool isValidBPFPreserveFieldInfoArg(Expr *Arg)
static bool checkUnsafeAssignLiteral(Sema &S, SourceLocation Loc, Expr *RHS, bool isProperty)
static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx)
Returns true if pipe element type is different from the pointer.
static ExprResult SemaBuiltinLaunder(Sema &S, CallExpr *TheCall)
static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc)
Analyzes an attempt to assign the given value to a bitfield.
static int classifyConstantValue(Expr *Constant)
static bool IsInAnyMacroBody(const SourceManager &SM, SourceLocation Loc)
static bool SemaBuiltinPipePackets(Sema &S, CallExpr *Call)
static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range, unsigned AbsKind, QualType ArgType)
static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall)
static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call)
Returns true if pipe element type is different from the pointer.
static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty)
static unsigned getAbsoluteValueFunctionKind(const FunctionDecl *FDecl)
static void diagnoseRetainCycle(Sema &S, Expr *capturer, RetainCycleOwner &owner)
static llvm::SmallPtrSet< MemberKind *, 1 > CXXRecordMembersNamed(StringRef Name, Sema &S, QualType Ty)
static QualType getNeonEltType(NeonTypeFlags Flags, ASTContext &Context, bool IsPolyUnsigned, bool IsInt64Long)
getNeonEltType - Return the QualType corresponding to the elements of the vector type specified by th...
static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T, SourceLocation CC)
static bool CheckBuiltinTargetInSupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ArchType > SupportedArchs)
static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall)
Check that the first argument to __builtin_annotation is an integer and the second argument is a non-...
static void CheckNonNullArguments(Sema &S, const NamedDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< const Expr * > Args, SourceLocation CallSiteLoc)
static unsigned getLargerAbsoluteValueFunction(unsigned AbsFunction)
static bool findRetainCycleOwner(Sema &S, Expr *e, RetainCycleOwner &owner)
static std::optional< int > GetNSSetArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool referToTheSameDecl(const Expr *E1, const Expr *E2)
Check if two expressions refer to the same declaration.
static bool requiresParensToAddCast(const Expr *E)
static const Expr * ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx)
static void checkObjCCollectionLiteralElement(Sema &S, QualType TargetElementType, Expr *Element, unsigned ElementKind)
Check a single element within a collection literal against the target element type.
static bool CheckWasmBuiltinArgIsInteger(Sema &S, CallExpr *E, unsigned ArgIndex)
Checks the argument at the given index is an integer.
static std::optional< unsigned > getAndVerifyMatrixDimension(Expr *Expr, StringRef Name, Sema &S)
static bool checkArgCountRange(Sema &S, CallExpr *Call, unsigned MinArgCount, unsigned MaxArgCount)
Checks that a call expression's argument count is in the desired range.
static bool convertArgumentToType(Sema &S, Expr *&Value, QualType Ty)
static bool checkArgCount(Sema &S, CallExpr *Call, unsigned DesiredArgCount)
Checks that a call expression's argument count is the desired number.
static const Expr * getSizeOfExprArg(const Expr *E)
If E is a sizeof expression, returns its argument expression, otherwise returns NULL.
static void DiagnoseIntInBoolContext(Sema &S, Expr *E)
static bool CheckBuiltinTargetNotInUnsupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef< llvm::Triple::ObjectFormatType > UnsupportedObjectFormatTypes)
static CharUnits getPresumedAlignmentOfPointer(const Expr *E, Sema &S)
static std::optional< int > GetNSMutableArrayArgumentIndex(Sema &S, ObjCMessageExpr *Message)
static bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn)
Check that the user is calling the appropriate va_start builtin for the target and calling convention...
static bool IsEnumConstOrFromMacro(Sema &S, Expr *E)
static bool GetMatchingCType(const IdentifierInfo *ArgumentKind, const Expr *TypeExpr, const ASTContext &Ctx, const llvm::DenseMap< Sema::TypeTagMagicValue, Sema::TypeTagData > *MagicValues, bool &FoundWrongKind, Sema::TypeTagData &TypeInfo, bool isConstantEvaluated)
Retrieve the C type corresponding to type tag TypeExpr.
static void checkObjCArrayLiteral(Sema &S, QualType TargetType, ObjCArrayLiteral *ArrayLiteral)
Check an Objective-C array literal being converted to the given target type.
static bool isLayoutCompatibleUnion(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2)
Check if two standard-layout unions are layout-compatible.
static bool SemaOpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID, CallExpr *Call)
static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str, unsigned &Mask)
DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str, advancing the pointer ov...
static QualType getAbsoluteValueArgumentType(ASTContext &Context, unsigned AbsType)
static void DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, const NamedDecl *FDecl, Expr **Args, unsigned NumArgs)
Diagnose use of s directive in an NSString which is being passed as formatting string to formatting m...
static bool isNonNullType(QualType type)
Determine whether the given type has a non-null nullability annotation.
static constexpr unsigned short combineFAPK(Sema::FormatArgumentPassingKind A, Sema::FormatArgumentPassingKind B)
static std::optional< std::pair< CharUnits, CharUnits > > getBaseAlignmentAndOffsetFromPtr(const Expr *E, ASTContext &Ctx)
This helper function takes a pointer expression and returns the alignment of a VarDecl and a constant...
static bool IsShiftedByte(llvm::APSInt Value)
static unsigned getBestAbsFunction(ASTContext &Context, QualType ArgType, unsigned AbsFunctionKind)
static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex)
checkBuiltinArgument - Given a call to a builtin function, perform normal type-checking on the given ...
static void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E)
Analyze the operands of the given comparison.
static bool SemaBuiltinCommitRWPipe(Sema &S, CallExpr *Call)
static bool SemaBuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall)
static bool SemaOpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall)
OpenCL C v2.0, s6.13.17.6 - Check the argument to the get_kernel_work_group_size and get_kernel_prefe...
static bool isPPC_64Builtin(unsigned BuiltinID)
static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call)
static bool isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE)
Return true if ICE is an implicit argument promotion of an arithmetic type.
static bool isValidBPFPreserveEnumValueArg(Expr *Arg)
static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC, bool IsListInit=false)
AnalyzeImplicitConversions - Find and report any interesting implicit conversions in the given expres...
static bool HasEnumType(Expr *E)
static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall, unsigned Start, unsigned End)
static std::optional< std::pair< CharUnits, CharUnits > > getAlignmentAndOffsetFromBinAddOrSub(const Expr *PtrE, const Expr *IntE, bool IsSub, ASTContext &Ctx)
Compute the alignment and offset of a binary additive operator.
static bool checkFPMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex)
static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall, Scope::ScopeFlags NeededScopeFlags, unsigned DiagID)
static bool checkArgCountAtMost(Sema &S, CallExpr *Call, unsigned MaxArgCount)
Checks that a call expression's argument count is at most the desired number.
static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam=nullptr)
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Provides definitions for the atomic synchronization scopes.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
Defines enumerations for the type traits support.
C Language Family Type Representation.
const NestedNameSpecifier * Specifier
__DEVICE__ int min(int __a, int __b)
__device__ __2f16 float __ockl_bool s
llvm::APInt getValue() const
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
APSInt & getComplexIntImag()
bool isComplexInt() const
bool isComplexFloat() const
APValue & getVectorElt(unsigned I)
unsigned getVectorLength() const
APSInt & getComplexIntReal()
APFloat & getComplexFloatImag()
APFloat & getComplexFloatReal()
bool isAddrLabelDiff() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getIntWidth(QualType T) const
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
QualType getRecordType(const RecordDecl *Decl) const
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const
Compare the rank of two floating point types as above, but compare equal if both types have the same ...
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
llvm::APFixedPoint getFixedPointMin(QualType Ty) const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getWebAssemblyExternrefType() const
Return a WebAssembly externref type.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CanQualType OCLClkEventTy
const clang::PrintingPolicy & getPrintingPolicy() const
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
QualType getExceptionObjectType(QualType T) const
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
CanQualType OCLReserveIDTy
CanQualType UnsignedShortTy
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
CanQualType getNSIntegerType() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
QualType DecodeTypeStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequireICE, bool AllowTypeModifiers) const
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
CanQualType getNSUIntegerType() const
uint64_t getCharWidth() const
Return the size of the character type, in bits.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getNonVirtualAlignment() const
getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
SourceLocation getQuestionLoc() const
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getRBracketLoc() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
QualType getElementType() const
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
std::unique_ptr< AtomicScopeModel > getScopeModel() const
Get atomic scope model.
SourceLocation getBeginLoc() const LLVM_READONLY
Attr - This represents one attribute.
const char * getSpelling() const
A builtin binary operation expression such as "x + y" or "x <= y".
static bool isLogicalOp(Opcode Opc)
SourceLocation getOperatorLoc() const
SourceLocation getExprLoc() const
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
bool isEqualityOp() const
static bool isAdditiveOp(Opcode Opc)
static bool isEqualityOp(Opcode Opc)
A fixed int type of a specified bitwidth.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
bool capturesVariable(const VarDecl *var) const
const ParmVarDecl * getParamDecl(unsigned i) const
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
const BlockDecl * getBlockDecl() const
QualType getPointeeType() const
This class is used for builtin types like 'int'.
bool isFloatingPoint() const
bool isSignedInteger() const
bool isUnsignedInteger() const
bool isAuxBuiltinID(unsigned ID) const
Return true if builtin ID belongs to AuxTarget.
const char * getHeaderName(unsigned ID) const
If this is a library function that comes from a specific header, retrieve that header name.
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
unsigned getAuxBuiltinID(unsigned ID) const
Return real builtin ID (i.e.
bool isTSBuiltin(unsigned ID) const
Return true if this function is a target-specific builtin.
const char * getRequiredFeatures(unsigned ID) const
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Represents a base class of a C++ class.
Represents a call to a C++ constructor.
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
A call to an overloaded operator written using operator syntax.
SourceLocation getExprLoc() const LLVM_READONLY
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents a C++ struct/union/class.
CXXRecordDecl * getDefinition() const
unsigned getNumBases() const
Retrieves the number of base classes of this class.
base_class_iterator bases_begin()
bool isDynamicClass() const
Represents a C++ nested-name-specifier or a global scope specifier.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
SourceLocation getBeginLoc() const LLVM_READONLY
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
bool isCallToStdMove() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr ** getArgs()
Retrieve the call arguments.
SourceLocation getRParenLoc() const
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
QualType withConst() const
Retrieves a version of this type with const applied.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
CastKind getCastKind() const
Represents a character-granular source range.
static CharSourceRange getCharRange(SourceRange R)
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
bool isOne() const
isOne - Test whether the quantity equals one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Complex values, per C99 6.2.5p11.
CompoundAssignOperator - For compound assignments (e.g.
CompoundLiteralExpr - [C99 6.5.2.5].
ConditionalOperator - The ?: ternary operator.
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
const llvm::APInt & getSize() const
Represents a concrete matrix type with constant number of rows and columns.
static constexpr unsigned getMaxElementsPerDimension()
Returns the maximum number of elements per dimension.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Expr * getOperand() const
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
SourceLocation getBeginLoc() const LLVM_READONLY
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
Decl - This represents one declaration (or definition), e.g.
bool isInStdNamespace() const
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
RAII class that determines when any errors have occurred between the time the instance was created an...
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
An instance of this object exists for each enum constant that is defined.
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
bool isComplete() const
Returns true if this can be considered a complete type.
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
EvaluatedExprVisitor - This class visits 'Expr *'s.
This represents one expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
@ SE_AllowSideEffects
Allow any unmodeled side effect.
@ SE_NoSideEffects
Strictly evaluate the expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const
If the current Expr is a pointer, this will try to statically determine the strlen of the string poin...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFixedPoint - Return true if this is a constant which we can fold and convert to a fixed poi...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreImplicitAsWritten() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_NotNull
Expression is not a Null pointer constant.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
bool isFlexibleArrayMemberLike(ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
void EvaluateForOverflow(const ASTContext &Ctx) const
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getBitWidthValue(const ASTContext &Ctx) const
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Expr * getBitWidth() const
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
llvm::APFloat getValue() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Represents a function declaration or definition.
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
const ParmVarDecl * getParamDecl(unsigned i) const
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Represents a prototype with parameter type info, e.g.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
ArrayRef< QualType > getParamTypes() const
FunctionType - C99 6.7.5.3 - Function Declarators.
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Describes an C or C++ initializer list.
unsigned getNumInits() const
const Expr * getInit(unsigned Init) const
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
StrictFlexArraysLevelKind
static StringRef getImmediateMacroName(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
static StringRef getImmediateMacroNameForDiagnostics(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
Retrieve the name of the immediate macro expansion.
Represents the results of name lookup.
bool empty() const
Return true if no decls were found.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
static bool isValidElementType(QualType T)
Valid elements types are the following:
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
@ ClassId_NSMutableOrderedSet
@ ClassId_NSMutableDictionary
NSSetMethodKind
Enumerates the NSMutableSet/NSOrderedSet methods used to apply some checks.
@ NSOrderedSet_setObjectAtIndex
@ NSOrderedSet_replaceObjectAtIndexWithObject
@ NSOrderedSet_setObjectAtIndexedSubscript
@ NSOrderedSet_insertObjectAtIndex
NSDictionaryMethodKind
Enumerates the NSDictionary/NSMutableDictionary methods used to generate literals and to apply some c...
@ NSMutableDict_setValueForKey
@ NSMutableDict_setObjectForKey
@ NSMutableDict_setObjectForKeyedSubscript
NSArrayMethodKind
Enumerates the NSArray/NSMutableArray methods used to generate literals and to apply some checks.
@ NSMutableArr_setObjectAtIndexedSubscript
@ NSMutableArr_insertObjectAtIndex
@ NSMutableArr_replaceObjectAtIndex
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool hasLinkage() const
Determine whether this declaration has linkage.
Represent a C++ namespace.
Flags to identify the types for overloaded Neon builtins.
EltType getEltType() const
NullStmt - This is the null statement ";": C99 6.8.3p3.
bool hasLeadingEmptyMacro() const
SourceLocation getSemiLoc() const
OpenMP 5.0 [2.1.5, Array Sections].
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Expr * getLowerBound()
Get lower bound of array section.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Represents an ObjC class declaration.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
SourceLocation getSuperLoc() const
Retrieve the location of the 'super' keyword for a class or instance message to 'super',...
Selector getSelector() const
@ SuperInstance
The receiver is the instance of the superclass object.
@ Instance
The receiver is an object instance.
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
const ObjCMethodDecl * getMethodDecl() const
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver.
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() const
ArrayRef< ParmVarDecl * > parameters() const
Represents a pointer to an Objective C object.
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
Represents one property declaration in an Objective-C interface.
ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
ObjCPropertyDecl * getExplicitProperty() const
const Expr * getBase() const
bool isImplicitProperty() const
SourceLocation getLocation() const
bool isSuperReceiver() const
ObjCStringLiteral, used for Objective-C string literals i.e.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
ParenExpr - This represents a parethesized expression, e.g.
Represents a parameter to a function.
QualType getElementType() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
PrimitiveDefaultInitializeKind
QualType withoutLocalFastQualifiers() const
QualType withConst() const
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
QualType withVolatile() const
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
void removeLocalVolatile()
bool isConstQualified() const
Determine whether this type is const-qualified.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
bool hasUnaligned() const
Represents a struct/union/class.
field_iterator field_end() const
field_range fields() const
field_iterator field_begin() const
Scope - A scope is a transient data structure that is used while parsing the program.
ScopeFlags
ScopeFlags - These are bitfields that are or'd together when creating a scope, which defines the sort...
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
@ SEHExceptScope
This scope corresponds to an SEH except.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isUnarySelector() const
unsigned getNumArgs() const
A generic diagnostic builder for errors which may or may not be deferred.
Sema - This implements semantic analysis and AST building for C.
const FieldDecl * getSelfAssignmentClassMemberCandidate(const ValueDecl *SelfAssigned)
Returns a field in a CXXRecordDecl that has the same name as the decl SelfAssigned when inside a CXXM...
ExprResult PerformImplicitConversion(Expr *From, QualType ToType, AssignmentAction Action, bool AllowExplicit=false)
PerformImplicitConversion - Perform an implicit conversion of the expression From to the type ToType.
bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function, const Expr *ThisArg, ArrayRef< const Expr * > Args, SourceLocation Loc)
Emit diagnostics for the diagnose_if attributes on Function, ignoring any non-ArgDependent DiagnoseIf...
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode)
Check for comparisons of floating-point values using == and !=.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupAnyName
Look up any declaration with any name.
void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull)
Register a magic integral constant to be used as a type tag.
bool isValidPointerAttrType(QualType T, bool RefOkay=false)
Determine if type T is a valid subject for a nonnull and similar attributes.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
void DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullType, bool IsEqual, SourceRange Range)
Diagnose pointers that are always non-null.
bool FormatStringHasSArg(const StringLiteral *FExpr)
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, ArithConvKind ACK)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6....
static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, bool IsVariadic, FormatStringInfo *FSI)
Given a FunctionDecl's FormatAttr, attempts to populate the FomatStringInfo parameter with the Format...
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void RefersToMemberWithReducedAlignment(Expr *E, llvm::function_ref< void(Expr *, RecordDecl *, FieldDecl *, CharUnits)> Action)
This function calls Action when it determines that E designates a misaligned member due to the packed...
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
ExprResult tryConvertExprToType(Expr *E, QualType Ty)
Try to convert an expression E to type Ty.
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
DiagnosticsEngine & getDiagnostics() const
static FormatStringType GetFormatStringType(const FormatAttr *Format)
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function's address can be taken or not, optionally emitting a diagnostic if...
std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc)
Warn if a value is moved to itself.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
const LangOptions & getLangOpts() const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange)
CheckCastAlign - Implements -Wcast-align, which warns when a pointer cast increases the alignment req...
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
bool hasCStrMethod(const Expr *E)
Check to see if a given expression could have '.c_str()' called on it.
const LangOptions & LangOpts
static const uint64_t MaximumAlignment
bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS)
checkUnsafeAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained type.
static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx)
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
void popCodeSynthesisContext()
void DiagnoseMisalignedMembers()
Diagnoses the current set of gathered accesses.
sema::FunctionScopeInfo * getCurFunction() const
void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS)
checkUnsafeExprAssigns - Check whether +1 expr is being assigned to weak/__unsafe_unretained expressi...
void pushCodeSynthesisContext(CodeSynthesisContext Ctx)
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
bool isConstantEvaluated() const
void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)
Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...
void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)
Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...
ExprResult DefaultLvalueConversion(Expr *E)
SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
FormatArgumentPassingKind
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
@ Compatible
Compatible - the types are compatible according to the standard.
@ ACK_Comparison
A comparison.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
void DiscardMisalignedMemberAddress(const Type *T, Expr *E)
This function checks if the expression is in the sef of potentially misaligned members and it is conv...
ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
SemaConvertVectorExpr - Handle __builtin_convertvector.
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
Helpers for dealing with blocks and functions.
std::pair< const IdentifierInfo *, uint64_t > TypeTagMagicValue
A pair of ArgumentKind identifier and magic value.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
SourceManager & SourceMgr
void checkRetainCycles(ObjCMessageExpr *msg)
checkRetainCycles - Check whether an Objective-C message send might create an obvious retain cycle.
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
NamespaceDecl * getStdNamespace() const
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
ExprResult BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder=AtomicArgumentOrder::API)
ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall)
SemaBuiltinShuffleVector - Handle __builtin_shufflevector.
@ Diagnose
Diagnose issues that are non-constant or that are extensions.
bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E)
CheckCXXThrowOperand - Validate the operand of a throw.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
This class handles loading and caching of source files into memory.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getBeginLoc() const LLVM_READONLY
StringKind getKind() const
unsigned getLength() const
StringKind
StringLiteral is followed by several trailing objects.
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
unsigned getByteLength() const
StringRef getString() const
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getCharByteWidth() const
Exposes information about the current target.
virtual bool validateCpuIs(StringRef Name) const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
IntType getInt64Type() const
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
IntType getSizeType() const
IntType getIntPtrType() const
uint32_t getARMCDECoprocMask() const
For ARM targets returns a mask defining which coprocessors are configured as Custom Datapath.
virtual bool validateCpuSupports(StringRef Name) const
const llvm::fltSemantics & getLongDoubleFormat() const
virtual bool checkArithmeticFenceSupported() const
Controls if __arithmetic_fence is supported in the targeted backend.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool hasSjLjLowering() const
Controls if __builtin_longjmp / __builtin_setjmp can be lowered to llvm.eh.sjlj.longjmp / llvm....
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
@ Type
The template argument is a type.
const Type * getTypeForDecl() const
Base wrapper for a particular "section" of type source info.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Represents a typeof (or typeof) expression (a C2x feature and GCC extension) or a typeof_unqual expre...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isFloat16Type() const
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isVLSTBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isFunctionPointerType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isScalarType() const
bool isVariableArrayType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
const BuiltinType * getAsPlaceholderType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
QualType getCanonicalTypeInternal() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isFunctionProtoType() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isRVVType(unsigned ElementCount) const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isFloatingType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
SourceLocation getBeginLoc() const LLVM_READONLY
The iterator over UnresolvedSets.
A set of unresolved declarations.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
Represents a variable declaration or definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Represents a GCC generic vector type.
unsigned getNumElements() const
@ GenericVector
not a target-specific vector type
@ AltiVecVector
is AltiVec vector
WhileStmt - This represents a 'while' stmt.
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
Defines the clang::TargetInfo interface.
__inline void unsigned int _2
const AstTypeMatcher< PointerType > pointerType
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
uint32_t Literal
Literals are represented as positive integers.
uint32_t Variable
Boolean variables are represented as positive integers.
ComparisonResult
Indicates the result of a tentative comparison.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
@ After
Like System, but searched after the system directories.
@ FixIt
Parse and apply any fixits to the source.
bool GT(InterpState &S, CodePtr OpPC)
bool Call(InterpState &S, CodePtr OpPC, const Function *Func)
bool NE(InterpState &S, CodePtr OpPC)
bool LE(InterpState &S, CodePtr OpPC)
bool InRange(InterpState &S, CodePtr OpPC)
bool Cast(InterpState &S, CodePtr OpPC)
bool EQ(InterpState &S, CodePtr OpPC)
bool GE(InterpState &S, CodePtr OpPC)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
bool isa(CodeGen::Address addr)
bool hasSpecificAttr(const Container &container)
@ NonNull
Values of this type can never be null.
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
for(unsigned I=0, E=TL.getNumArgs();I !=E;++I)
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ C
Languages that the frontend can parse and compile.
@ Result
The result type of a method or function.
ActionResult< ParsedType > TypeResult
LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
CallingConv
CallingConv - Specifies the calling convention that a function uses.
U cast(CodeGen::Address addr)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Extra information about a function prototype.
Describes how types, statements, expressions, and declarations should be printed.
unsigned AnonymousTagLocations
When printing an anonymous tag name, also print the location of that entity (e.g.,...
unsigned Indentation
The number of spaces to use to indent each line.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
SourceLocation PointOfInstantiation
The point of instantiation or synthesis within the source code.
unsigned NumCallArgs
The number of expressions in CallArgs.
const Expr *const * CallArgs
The list of argument expressions in a synthesized call.
@ BuildingBuiltinDumpStructCall
We are building an implied call from __builtin_dump_struct.
Iterator for iterating over Stmt * arrays that contain only T *.